@robbiesrobotics/alice-agents 1.4.3 → 1.4.5

package/README.md

@@ -18,6 +18,11 @@ That's it. The installer detects your runtime (NemoClaw or OpenClaw) and sets ev
 
 **Starter** includes 10 agents. **Pro** unlocks 18 more — [sign up at getalice.av3.ai](https://getalice.av3.ai/signup?plan=pro)
 
+**Mission Control Cloud** is available as a Pro add-on. If enabled during install, the package now:
+- installs the `mission-control-bridge` plugin into your OpenClaw home
+- writes a portable local Mission Control config at `~/.openclaw/.alice-mission-control.json`
+- enables the bridge in `openclaw.json` so your runtime can forward live telemetry to Mission Control
+
 An orchestrator (A.L.I.C.E., also addressable as Alice or Olivia) backed by specialist agents across every domain:
 
 | Agent | Domain | Emoji | Tier |
@@ -77,6 +82,9 @@ npx @robbiesrobotics/alice-agents
 # Non-interactive with defaults (detected model if available, otherwise Sonnet; Starter tier)
 npx @robbiesrobotics/alice-agents --yes
 
+# Non-interactive Pro install with Mission Control Cloud enabled
+npx @robbiesrobotics/alice-agents --cloud --cloud-token YOUR_TOKEN
+
 # Show help
 npx @robbiesrobotics/alice-agents --help
 ```
@@ -87,6 +95,19 @@ npx @robbiesrobotics/alice-agents --help
 - **Merge** — Adds A.L.I.C.E. agents alongside your existing agents
 - **Upgrade** — Updates product files (SOUL.md, AGENTS.md, etc.) without touching user customizations
 
+### Mission Control Cloud
+
+If you're a Pro user with the cloud add-on, the installer can configure your local runtime for Mission Control in the same pass.
+
+- Interactive install: choose `Pro`, validate your license, then enable the Mission Control Cloud add-on when prompted
+- Non-interactive install: pass `--cloud`
+- Optional flags:
+  - `--cloud-token <token>` — access or ingest token for authenticated telemetry
+  - `--cloud-dashboard-url <url>` — defaults to `https://alice.av3.ai`
+  - `--cloud-ingest-url <url>` — defaults to `<dashboard-url>/api/v1/ingest`
+
+The cloud config is stored in `~/.openclaw/.alice-mission-control.json`, and the bundled bridge plugin reads from that file so the setup remains portable across macOS, Linux, and Windows.
+
 ## Upgrade
 
 Re-run the installer and choose "Upgrade":

package/bin/alice-install.mjs

@@ -9,6 +9,12 @@ import { runSkillsManager } from '../lib/skills.mjs';
 const args = process.argv.slice(2);
 const flags = new Set(args);
 
+function getFlagValue(name) {
+  const idx = args.indexOf(name);
+  if (idx === -1) return undefined;
+  return args[idx + 1];
+}
+
 if (flags.has('--version') || flags.has('-v')) {
   const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url)));
   console.log(pkg.version);
@@ -26,6 +32,7 @@ if (flags.has('--help') || flags.has('-h')) {
     npx @robbiesrobotics/alice-agents --uninstall  Remove A.L.I.C.E. agents from config
     npx @robbiesrobotics/alice-agents --doctor     Run diagnostics on your A.L.I.C.E. install
     npx @robbiesrobotics/alice-agents --skills     Manage skills (install, remove, browse)
+    npx @robbiesrobotics/alice-agents --cloud      Enable Mission Control Cloud during install
     npx @robbiesrobotics/alice-agents --version    Show version
     npx @robbiesrobotics/alice-agents --help       Show this help
 
@@ -34,6 +41,11 @@ if (flags.has('--help') || flags.has('-h')) {
     --update      Non-interactive upgrade (alias for --yes with upgrade mode)
     --uninstall   Remove A.L.I.C.E. agents (preserves non-ALICE agents)
     --doctor      Run diagnostics and check install health
+    --cloud       Enable Mission Control Cloud setup during install
+    --no-cloud    Skip Mission Control Cloud setup during install
+    --cloud-token <token>           Mission Control ingest/access token
+    --cloud-dashboard-url <url>     Mission Control dashboard URL
+    --cloud-ingest-url <url>        Mission Control ingest endpoint
     --version     Print package version
   `);
   process.exit(0);
@@ -45,7 +57,14 @@ if (flags.has('--doctor')) {
     process.exit(1);
   });
 } else if (flags.has('--update')) {
-  runInstall({ yes: true, modeOverride: 'upgrade' }).catch((err) => {
+  runInstall({
+    yes: true,
+    modeOverride: 'upgrade',
+    cloud: flags.has('--cloud') ? true : flags.has('--no-cloud') ? false : undefined,
+    cloudToken: getFlagValue('--cloud-token'),
+    cloudDashboardUrl: getFlagValue('--cloud-dashboard-url'),
+    cloudIngestUrl: getFlagValue('--cloud-ingest-url'),
+  }).catch((err) => {
     console.error('  ❌ Update failed:', err.message);
     process.exit(1);
   });
@@ -60,7 +79,13 @@ if (flags.has('--doctor')) {
     process.exit(1);
   });
 } else {
-  runInstall({ yes: flags.has('--yes') }).catch((err) => {
+  runInstall({
+    yes: flags.has('--yes'),
+    cloud: flags.has('--cloud') ? true : flags.has('--no-cloud') ? false : undefined,
+    cloudToken: getFlagValue('--cloud-token'),
+    cloudDashboardUrl: getFlagValue('--cloud-dashboard-url'),
+    cloudIngestUrl: getFlagValue('--cloud-ingest-url'),
+  }).catch((err) => {
     console.error('  ❌ Install failed:', err.message);
     process.exit(1);
   });

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/installer.mjs

@@ -6,6 +6,7 @@ import { homedir } from 'node:os';
 import { configExists, mergeConfig, removeAliceAgents, detectAvailableModels } from './config-merger.mjs';
 import { scaffoldAll } from './workspace-scaffolder.mjs';
 import { readManifest, writeManifest } from './manifest.mjs';
+import { configureMissionControlCloud, getDefaultMissionControlSettings } from './mission-control.mjs';
 import {
   promptInstallMode,
   promptUserInfo,
@@ -13,6 +14,8 @@ import {
   promptCustomModel,
   promptTier,
   promptLicenseKey,
+  promptCloudAddon,
+  promptMissionControlToken,
   confirm,
   choose,
   input,
@@ -440,6 +443,10 @@ function printBanner() {
 }
 
 function printSummary(mode, tier, agents, preset, userInfo, detectedModels) {
+  return printSummaryWithOptions(mode, tier, agents, preset, userInfo, detectedModels, null);
+}
+
+function printSummaryWithOptions(mode, tier, agents, preset, userInfo, detectedModels, missionControl) {
   const modelLabel =
     preset === 'detected'
       ? `${detectedModels?.primary || 'your configured model'} ${dim('(detected)')}`
@@ -454,6 +461,13 @@ function printSummary(mode, tier, agents, preset, userInfo, detectedModels) {
     `${dim('Model:')}     ${green(modelLabel)}`,
     `${dim('User:')}      ${green(userInfo.name)}`,
     `${dim('Timezone:')}  ${green(userInfo.timezone)}`,
+    `${dim('Mission Control:')}  ${green(missionControl?.enabled ? 'cloud enabled' : 'local only')}`,
+    ...(missionControl?.enabled
+      ? [
+          `${dim('Dashboard:')} ${green(missionControl.dashboardUrl)}`,
+          `${dim('Ingest:')}    ${green(missionControl.ingestUrl)}`,
+        ]
+      : []),
     '',
     `${dim('Agents:')}`,
     ...agents.map(a => `  ${icons.bullet} ${green(a.emoji)}  ${bold(a.name.padEnd(10))} ${dim('─')} ${a.domain}`),
@@ -465,6 +479,7 @@ function printSummary(mode, tier, agents, preset, userInfo, detectedModels) {
 
 export async function runInstall(options = {}) {
   const auto = options.yes || false;
+  const manifest = readManifest();
 
   // Check health flag first (before banner)
   if (process.argv.includes('--health')) {
@@ -534,14 +549,12 @@ export async function runInstall(options = {}) {
   if (options.modeOverride) {
     mode = options.modeOverride;
   } else if (auto) {
-    const manifest = readManifest();
     mode = manifest ? 'upgrade' : 'fresh';
   } else {
     mode = await promptInstallMode();
   }
 
   if (mode === 'upgrade') {
-    const manifest = readManifest();
     if (!manifest) {
       console.log(`  ${icons.warn} ${yellow('No previous install found. Switching to fresh install.')}\n`);
       mode = 'fresh';
@@ -644,10 +657,43 @@ export async function runInstall(options = {}) {
     }
   }
 
+  let missionControl = null;
+  const existingMissionControl = manifest?.missionControl;
+  if (tier === 'pro') {
+    const cloudFlag = options.cloud === true ? true : options.cloud === false ? false : null;
+    const enableCloud = auto
+      ? cloudFlag ?? existingMissionControl?.enabled ?? false
+      : cloudFlag ?? await promptCloudAddon();
+
+    if (enableCloud) {
+      const defaults = getDefaultMissionControlSettings();
+      const dashboardUrl =
+        String(options.cloudDashboardUrl || existingMissionControl?.dashboardUrl || defaults.dashboardUrl).trim();
+      const ingestUrl =
+        String(options.cloudIngestUrl || existingMissionControl?.ingestUrl || `${dashboardUrl}/api/v1/ingest`).trim();
+      const ingestToken =
+        auto
+          ? String(options.cloudToken || '').trim()
+          : String(options.cloudToken || await promptMissionControlToken()).trim();
+      const sourceNode =
+        String(options.cloudSourceNode || existingMissionControl?.sourceNode || defaults.sourceNode).trim();
+
+      missionControl = {
+        enabled: true,
+        provider: 'cloud',
+        dashboardUrl,
+        ingestUrl,
+        sourceNode,
+        hasIngestToken: !!ingestToken,
+        ingestToken,
+      };
+    }
+  }
+
   const agents = allAgents;
 
   // 6. Confirmation
-  printSummary(mode, tier, agents, preset, userInfo, detectedModels);
+  printSummaryWithOptions(mode, tier, agents, preset, userInfo, detectedModels, missionControl);
 
   if (!auto) {
     const ok = await confirm('  Proceed with installation?');
@@ -676,6 +722,16 @@ export async function runInstall(options = {}) {
     console.log(`  ${icons.warn} ${yellow(warning)}`);
   }
 
+  if (missionControl?.enabled) {
+    const missionControlResult = configureMissionControlCloud(missionControl);
+    printStepDone('Mission Control cloud', missionControlResult.summary.dashboardUrl);
+    if (!missionControlResult.summary.hasIngestToken) {
+      printStepSkip('Cloud access token not set', 'bridge installed; add token later to enable authenticated ingest');
+    }
+  } else {
+    printStepSkip('Mission Control cloud', 'not enabled for this install');
+  }
+
   // Scaffold workspaces
   const results = scaffoldAll(agents, userInfo);
   let newWorkspaces = 0;
@@ -706,6 +762,16 @@ export async function runInstall(options = {}) {
     userName: userInfo.name,
     userTimezone: userInfo.timezone,
     modelPreset: effectivePreset,
+    missionControl: missionControl
+      ? {
+          enabled: true,
+          provider: 'cloud',
+          dashboardUrl: missionControl.dashboardUrl,
+          ingestUrl: missionControl.ingestUrl,
+          sourceNode: missionControl.sourceNode,
+          bridgeInstalled: true,
+        }
+      : existing?.missionControl || null,
   });
   printStepDone('Manifest written');
 

package/lib/manifest.mjs

@@ -27,6 +27,7 @@ export function writeManifest(data) {
     userName: data.userName,
     userTimezone: data.userTimezone,
     modelPreset: data.modelPreset,
+    missionControl: data.missionControl || null,
   };
   writeFileSync(getManifestPath(), JSON.stringify(manifest, null, 2) + '\n', 'utf8');
   return manifest;

package/lib/mission-control.mjs

@@ -0,0 +1,169 @@
+import { cpSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { homedir, hostname } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const OPENCLAW_HOME = process.env.OPENCLAW_HOME || join(homedir(), '.openclaw');
+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');
+
+function normalizeUrl(url, fallback) {
+  const value = String(url || fallback || '').trim();
+  if (!value) return '';
+  return value.replace(/\/+$/, '');
+}
+
+function atomicWriteJSON(targetPath, data) {
+  const tmpPath = `${targetPath}.tmp`;
+  writeFileSync(tmpPath, JSON.stringify(data, null, 2) + '\n', 'utf8');
+  renameSync(tmpPath, targetPath);
+}
+
+function readJsonFile(path) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function getMissionControlConfigPath() {
+  return MC_CONFIG_PATH;
+}
+
+export function readMissionControlConfig() {
+  return readJsonFile(MC_CONFIG_PATH);
+}
+
+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 } : {}),
+  };
+}
+
+export function writeMissionControlConfig(input = {}) {
+  mkdirSync(OPENCLAW_HOME, { recursive: true });
+
+  const existing = readMissionControlConfig();
+  const settings = buildMissionControlSettings({
+    ...existing?.cloud,
+    ...input,
+  });
+
+  const config = {
+    version: 1,
+    updatedAt: new Date().toISOString(),
+    cloud: settings,
+  };
+
+  atomicWriteJSON(MC_CONFIG_PATH, config);
+  return { path: MC_CONFIG_PATH, config };
+}
+
+function ensureBridgeFiles(targetPath) {
+  mkdirSync(dirname(targetPath), { recursive: true });
+  cpSync(TEMPLATE_DIR, targetPath, { recursive: true, force: true });
+}
+
+export function installMissionControlBridge() {
+  const sourcePath = join(OPENCLAW_HOME, 'plugins', BRIDGE_ID);
+  const installPath = join(OPENCLAW_HOME, 'extensions', BRIDGE_ID);
+
+  ensureBridgeFiles(sourcePath);
+  ensureBridgeFiles(installPath);
+
+  return { sourcePath, installPath };
+}
+
+export function enableMissionControlBridge() {
+  const config = readJsonFile(CONFIG_PATH);
+  if (!config) {
+    throw new Error('OpenClaw config not found. Run openclaw configure first.');
+  }
+
+  const existingInstall = config?.plugins?.installs?.[BRIDGE_ID] || {};
+  const { sourcePath, installPath } = installMissionControlBridge();
+  const pkg = readJsonFile(join(TEMPLATE_DIR, 'package.json')) || {};
+
+  config.plugins = config.plugins || {};
+  config.plugins.entries = config.plugins.entries || {};
+  config.plugins.installs = config.plugins.installs || {};
+
+  config.plugins.entries[BRIDGE_ID] = {
+    ...(config.plugins.entries[BRIDGE_ID] || {}),
+    enabled: true,
+  };
+
+  config.plugins.installs[BRIDGE_ID] = {
+    source: 'path',
+    sourcePath,
+    installPath,
+    version: pkg.version || existingInstall.version || '1.0.0',
+    installedAt: existingInstall.installedAt || new Date().toISOString(),
+  };
+
+  atomicWriteJSON(CONFIG_PATH, config);
+  return { configPath: CONFIG_PATH, sourcePath, installPath };
+}
+
+export function configureMissionControlCloud(input = {}) {
+  const configResult = writeMissionControlConfig(input);
+  const bridgeResult = enableMissionControlBridge();
+  const settings = configResult.config.cloud;
+
+  return {
+    configPath: configResult.path,
+    bridgeSourcePath: bridgeResult.sourcePath,
+    bridgeInstallPath: bridgeResult.installPath,
+    summary: {
+      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,
+    },
+  };
+}
+
+export function getDefaultMissionControlSettings() {
+  return buildMissionControlSettings();
+}
+
+export function hasMissionControlBridgeInstalled() {
+  return existsSync(join(OPENCLAW_HOME, 'extensions', BRIDGE_ID));
+}

package/lib/prompter.mjs

@@ -125,3 +125,19 @@ export async function promptLicenseKey() {
     });
   });
 }
+
+export async function promptCloudAddon() {
+  console.log('');
+  console.log('  Mission Control Cloud add-on');
+  console.log('  Hosted dashboard, telemetry sync, and cloud memory for Pro users.');
+  console.log('');
+  return confirm('  Enable the Mission Control Cloud add-on on this machine?', true);
+}
+
+export async function promptMissionControlToken() {
+  console.log('');
+  console.log('  Enter your Mission Control cloud access token if you have one.');
+  console.log('  Press Enter to skip for now — you can add it later without reinstalling.');
+  console.log('');
+  return input('  Mission Control access token', '');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robbiesrobotics/alice-agents",
-  "version": "1.4.3",
+  "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"
@@ -23,6 +23,7 @@
     "tools/",
     "snapshots/",
     "templates/agents-starter.json",
+    "templates/mission-control-bridge/",
     "templates/skills/",
     "templates/workspaces/",
     "SELF-HEALING-SPEC.md",

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

@@ -0,0 +1,674 @@
+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 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_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;
+
+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")) as JsonRecord;
+  } catch {
+    return {};
+  }
+}
+
+function getCloudConfig(): JsonRecord {
+  const fileConfig = readMissionControlConfig();
+  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 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();
+}
+
+function sessionKeyToAgentId(sessionKey?: string): string {
+  if (!sessionKey) return "unknown";
+  const parts = sessionKey.split(":");
+  return parts[1] ?? parts[0] ?? "unknown";
+}
+
+let seq = 0;
+function nextId(prefix: string): string {
+  return `${prefix}-${Date.now()}-${++seq}`;
+}
+
+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,
+    },
+  };
+  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 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) {
+      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) {
+    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);
+  }
+}
+
+function handleModelUsage(evt: Extract<DiagnosticEventPayload, { type: "model.usage" }>) {
+  const agentId = sessionKeyToAgentId(evt.sessionKey);
+  const totalTokens = evt.usage.total ?? (evt.usage.input ?? 0) + (evt.usage.output ?? 0);
+
+  const event = {
+    event_id: nextId("mc-bridge"),
+    event_type: "agent.session.completed",
+    event_version: "1.0",
+    source_system: "openclaw",
+    source_node: SOURCE_NODE,
+    occurred_at: now(),
+    actor_id: agentId,
+    actor_type: "agent",
+    correlation_id: evt.sessionId ?? null,
+    payload: {
+      session_id: evt.sessionId ?? evt.sessionKey ?? nextId("sess"),
+      agent_id: agentId,
+      model: evt.model ?? "unknown",
+      channel: evt.channel ?? "unknown",
+      total_tokens: totalTokens,
+      input_tokens: evt.usage.input ?? 0,
+      output_tokens: evt.usage.output ?? 0,
+      cache_read_tokens: evt.usage.cacheRead ?? 0,
+      cache_write_tokens: evt.usage.cacheWrite ?? 0,
+      cost_usd: evt.costUsd ?? 0,
+      duration_ms: evt.durationMs ?? 0,
+      context_limit: evt.context?.limit ?? 0,
+      context_used: evt.context?.used ?? 0,
+      status: "completed",
+    },
+  };
+
+  void postToIngest([event]);
+}
+
+function handleMessageProcessed(evt: Extract<DiagnosticEventPayload, { type: "message.processed" }>) {
+  if (!evt.sessionKey && !evt.sessionId) return;
+  const agentId = sessionKeyToAgentId(evt.sessionKey);
+  const eventType =
+    evt.outcome === "completed"
+      ? "agent.session.completed"
+      : evt.outcome === "error"
+        ? "agent.session.completed"
+        : null;
+
+  if (!eventType) return;
+
+  const event = {
+    event_id: nextId("mc-bridge"),
+    event_type: eventType,
+    event_version: "1.0",
+    source_system: "openclaw",
+    source_node: SOURCE_NODE,
+    occurred_at: now(),
+    actor_id: agentId,
+    actor_type: "agent",
+    correlation_id: evt.sessionId ?? null,
+    payload: {
+      session_id: evt.sessionId ?? evt.sessionKey ?? nextId("sess"),
+      agent_id: agentId,
+      channel: evt.channel ?? "unknown",
+      status: evt.outcome === "error" ? "failed" : "completed",
+      duration_ms: evt.durationMs ?? 0,
+      ...(evt.error ? { error: evt.error } : {}),
+    },
+  };
+
+  void postToIngest([event]);
+}
+
+function handleSessionState(evt: Extract<DiagnosticEventPayload, { type: "session.state" }>) {
+  if (!evt.sessionKey && !evt.sessionId) return;
+  const agentId = sessionKeyToAgentId(evt.sessionKey);
+  const stateToEventType: Record<string, string> = {
+    processing: "agent.session.started",
+    idle: "agent.session.completed",
+  };
+  const eventType = stateToEventType[evt.state];
+  if (!eventType) return;
+
+  const event = {
+    event_id: nextId("mc-bridge"),
+    event_type: eventType,
+    event_version: "1.0",
+    source_system: "openclaw",
+    source_node: SOURCE_NODE,
+    occurred_at: now(),
+    actor_id: agentId,
+    actor_type: "agent",
+    correlation_id: evt.sessionId ?? null,
+    payload: {
+      session_id: evt.sessionId ?? evt.sessionKey ?? nextId("sess"),
+      agent_id: agentId,
+      state: evt.state,
+      prev_state: evt.prevState ?? null,
+    },
+  };
+
+  void postToIngest([event]);
+}
+
+const plugin = {
+  id: "mission-control-bridge",
+  name: "Mission Control Bridge",
+  description: "Forwards OpenClaw diagnostic events to A.L.I.C.E. Mission Control and executes hosted runtime commands",
+  configSchema: emptyPluginConfigSchema(),
+
+  register(api: OpenClawPluginApi) {
+    api.registerService({
+      id: "mission-control-bridge",
+
+      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 {
+            switch (evt.type) {
+              case "model.usage":
+                handleModelUsage(evt);
+                break;
+              case "message.processed":
+                handleMessageProcessed(evt);
+                break;
+              case "session.state":
+                handleSessionState(evt);
+                break;
+            }
+          } catch (err) {
+            ctx.logger.warn(`[mc-bridge] event handler error (${evt.type}): ${String(err)}`);
+          }
+        });
+
+        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: nextId("mc-bridge"),
+            event_type: "node.registered",
+            event_version: "1.0",
+            source_system: "openclaw",
+            source_node: SOURCE_NODE,
+            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;
+          _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;
+      },
+    });
+  },
+};
+
+export default plugin;

package/templates/mission-control-bridge/openclaw.plugin.json

@@ -0,0 +1,8 @@
+{
+  "id": "mission-control-bridge",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/templates/mission-control-bridge/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@alice/mission-control-bridge",
+  "version": "1.0.0",
+  "description": "Bridges OpenClaw diagnostic events to Mission Control ingest endpoint",
+  "type": "module",
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}