@robbiesrobotics/alice-agents 1.4.3 → 1.4.4

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/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,150 @@
+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_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 ingestUrl = normalizeUrl(input.ingestUrl, `${dashboardUrl}/api/v1/ingest`);
+  const sourceNode = String(input.sourceNode || hostname() || 'openclaw-local').trim();
+  const ingestToken = String(input.ingestToken || '').trim();
+
+  return {
+    enabled: input.enabled !== false,
+    provider: 'cloud',
+    dashboardUrl,
+    ingestUrl,
+    sourceNode,
+    ...(ingestToken ? { ingestToken } : {}),
+  };
+}
+
+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,
+      ingestUrl: settings.ingestUrl,
+      sourceNode: settings.sourceNode,
+      hasIngestToken: !!settings.ingestToken,
+    },
+  };
+}
+
+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.4",
   "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,233 @@
+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_INGEST_URL = "https://alice.av3.ai/api/v1/ingest";
+
+function readMissionControlConfig(): Record<string, unknown> {
+  try {
+    if (!existsSync(MC_CONFIG_PATH)) return {};
+    return JSON.parse(readFileSync(MC_CONFIG_PATH, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+function getCloudConfig(): Record<string, unknown> {
+  const fileConfig = readMissionControlConfig();
+  return typeof fileConfig.cloud === "object" && fileConfig.cloud ? fileConfig.cloud as Record<string, unknown> : {};
+}
+
+function getString(value: unknown, fallback = ""): string {
+  return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+
+const cloudConfig = getCloudConfig();
+const INGEST_URL = getString(process.env.MC_INGEST_URL, getString(cloudConfig.ingestUrl, DEFAULT_INGEST_URL));
+const INGEST_TOKEN = getString(process.env.MC_INGEST_TOKEN, getString(cloudConfig.ingestToken));
+const SOURCE_NODE = getString(process.env.MC_SOURCE_NODE, getString(cloudConfig.sourceNode, "openclaw-local"));
+
+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 nextEventId(): string {
+  return `mc-bridge-${Date.now()}-${++seq}`;
+}
+
+async function postToIngest(events: object[]): Promise<void> {
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+  };
+  if (INGEST_TOKEN) {
+    headers["Authorization"] = `Bearer ${INGEST_TOKEN}`;
+  }
+
+  try {
+    const res = await fetch(INGEST_URL, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(events),
+      signal: AbortSignal.timeout(8000),
+    });
+    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 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: nextEventId(),
+    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 ?? nextEventId(),
+      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",
+    },
+  };
+
+  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: nextEventId(),
+    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 ?? nextEventId(),
+      agent_id: agentId,
+      channel: evt.channel ?? "unknown",
+      status: evt.outcome === "error" ? "failed" : "completed",
+      duration_ms: evt.durationMs ?? 0,
+      ...(evt.error ? { error: evt.error } : {}),
+    },
+  };
+
+  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: nextEventId(),
+    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 ?? nextEventId(),
+      agent_id: agentId,
+      state: evt.state,
+      prev_state: evt.prevState ?? null,
+    },
+  };
+
+  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",
+  configSchema: emptyPluginConfigSchema(),
+
+  register(api: OpenClawPluginApi) {
+    api.registerService({
+      id: "mission-control-bridge",
+
+      async start(ctx) {
+        ctx.logger.info(`[mc-bridge] starting — ingest URL: ${INGEST_URL}`);
+
+        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)}`);
+          }
+        });
+
+        (this as { _unsub?: () => void })._unsub = unsubscribe;
+
+        await postToIngest([
+          {
+            event_id: nextEventId(),
+            event_type: "node.registered",
+            event_version: "1.0",
+            source_system: "openclaw",
+            source_node: SOURCE_NODE,
+            occurred_at: now(),
+            payload: {
+              node_name: SOURCE_NODE,
+              platform: process.platform,
+              node_version: process.version,
+            },
+          },
+        ]);
+      },
+
+      async stop() {
+        const self = this as { _unsub?: () => void };
+        self._unsub?.();
+        self._unsub = 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"
+    ]
+  }
+}