robot-resources 1.9.7 → 1.10.2

package/README.md

@@ -57,7 +57,6 @@ Available as MCP tool after install:
 ## MCP Servers
 
 ```bash
-npx -y @robot-resources/router-mcp    # Router stats + config
 npx -y @robot-resources/scraper-mcp   # Scraper compression
 ```
 

package/lib/detect.js

@@ -1,46 +1,8 @@
-import { execSync, execFileSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { stripJson5 } from './json5.js';
 
-// Re-export findPython from the shared cli-core implementation.
-export { findPython } from '@robot-resources/cli-core/python-bridge.mjs';
-
-import { getVenvPython, MANAGED_VENV_DIR } from '@robot-resources/cli-core/python-bridge.mjs';
-
-/**
- * Check if the router venv exists and has the package installed.
- * Returns { venvDir, venvPython } or null.
- */
-export function checkRouterVenv() {
-  const venvPython = getVenvPython();
-
-  if (!existsSync(venvPython)) return null;
-
-  try {
-    execSync(`"${venvPython}" -c "import robot_resources" 2>&1`, { encoding: 'utf-8' });
-    return { venvDir: MANAGED_VENV_DIR, venvPython };
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Check if port 3838 is available.
- */
-export function isPortAvailable(port = 3838) {
-  if (typeof port !== 'number' || !Number.isInteger(port) || port < 1 || port > 65535) {
-    throw new Error('Invalid port number');
-  }
-  try {
-    execFileSync('lsof', ['-i', `:${port}`, '-t'], { encoding: 'utf-8', stdio: 'pipe' });
-    return false; // port is in use
-  } catch {
-    return true; // port is available (lsof returned non-zero = no process)
-  }
-}
-
 /**
  * Check if OpenClaw is installed.
  */
@@ -154,18 +116,3 @@ export function isClaudeCodeInstalled() {
 export function isCursorInstalled() {
   return existsSync(join(homedir(), '.cursor'));
 }
-
-/**
- * Check if the router service is already registered.
- */
-export function isServiceRegistered() {
-  if (process.platform === 'darwin') {
-    const plistPath = join(homedir(), 'Library', 'LaunchAgents', 'ai.robotresources.router.plist');
-    return existsSync(plistPath);
-  }
-  if (process.platform === 'linux') {
-    const unitPath = join(homedir(), '.config', 'systemd', 'user', 'robot-resources-router.service');
-    return existsSync(unitPath);
-  }
-  return false;
-}

package/lib/tool-config.js

@@ -96,17 +96,18 @@ function registerScraperMcp() {
 /**
  * Copy the bundled plugin files to ~/.openclaw/extensions/openclaw-plugin/.
  *
- * The plugin ships as a CLI dependency (@robot-resources/openclaw-plugin).
+ * The plugin ships as a CLI dependency (@robot-resources/router — the
+ * router IS the OC plugin in the in-process architecture).
  * Instead of spawning `openclaw plugins install` (30s npm overhead),
  * we copy files directly. Same destination, same result.
  *
- * Since 0.5.5, the plugin is a thin shim (index.js) that imports the rest
+ * The plugin is a thin shim (index.js) that imports the rest
  * of its code from ./lib/*.js — copy the lib/ directory too, or the shim
  * fails to load with MODULE_NOT_FOUND.
  */
 function installPluginFiles() {
   const require = createRequire(import.meta.url);
-  const pluginPkgPath = require.resolve('@robot-resources/openclaw-plugin/package.json');
+  const pluginPkgPath = require.resolve('@robot-resources/router/package.json');
   const pluginDir = dirname(pluginPkgPath);
 
   const targetDir = join(homedir(), '.openclaw', 'extensions', 'openclaw-plugin');
@@ -153,7 +154,7 @@ function registerPluginEntry() {
 /**
  * Configure OpenClaw to route through Robot Resources Router.
  *
- * Copies the bundled @robot-resources/openclaw-plugin files into
+ * Copies the bundled @robot-resources/router files into
  * ~/.openclaw/extensions/. The plugin uses before_model_resolve to
  * override the provider — survives gateway restarts because it
  * lives in ~/.openclaw/extensions/, not in openclaw.json.
@@ -196,7 +197,7 @@ function configureOpenClaw() {
     // Plugin file copy failed — fall back to instructions
     const instructions = [
       'Could not auto-install plugin. Install manually:',
-      '  openclaw plugins install @robot-resources/openclaw-plugin',
+      '  openclaw plugins install @robot-resources/router',
     ];
 
     if (authMode === 'subscription') {

package/lib/wizard.js

@@ -2,20 +2,18 @@ import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir, hostname, release as osRelease } from 'node:os';
 import { readConfig, writeConfig } from '@robot-resources/cli-core/config.mjs';
-import { findPython, isPortAvailable, isHeadless, isOpenClawInstalled } from './detect.js';
+import { isOpenClawInstalled } from './detect.js';
 import { getOrCreateMachineId } from './machine-id.js';
-import { setupRouter, isRouterInstalled, getVenvPythonPath } from './python-bridge.js';
-import { installService, isServiceRunning, isServiceInstalled } from './service.js';
 import { configureToolRouting, registerScraperMcp, restartOpenClawGateway } from './tool-config.js';
 import { checkHealth } from './health-report.js';
 import { header, step, success, warn, error, info, blank, summary } from './ui.js';
 
 // Stamped onto every CLI telemetry payload so we can tell which `robot-resources`
 // version a user actually ran. Without this, npx-cached old installers look
-// identical to fresh runs in Supabase — which is exactly the visibility gap
-// that left us blind on real-user install failures despite shipping rich
-// diagnostics in PR #163. Read once at module load; safe to fail (telemetry
-// just lands without the field).
+// identical to fresh runs in Supabase — exactly the visibility gap that left
+// us blind on real-user install failures despite shipping rich diagnostics
+// in PR #163. Read once at module load; safe to fail (telemetry just lands
+// without the field).
 const CLI_VERSION = (() => {
   try {
     return JSON.parse(
@@ -25,87 +23,51 @@ const CLI_VERSION = (() => {
     return null;
   }
 })();
-/**
- * Classify an install error into a short reason code + bounded detail string.
- *
- * Before this existed, install_complete telemetry reported router:false with
- * no context — 100% of rr-router installs failed and we couldn't diagnose.
- * The reason code slots into a small enum so we can aggregate in the admin
- * dashboard; detail is the tail of stderr/error message for deep-dives.
- */
-function classifyRouterError(err) {
-  const msg = (err?.message || String(err)).toLowerCase();
-  const stderr = (err?.stderr || '').toString().toLowerCase();
-  const combined = msg + '\n' + stderr;
-  let reason = 'unknown';
-
-  // Order matters — check specific patterns before generic ones.
-  // python_venv_missing is specific (Debian/Ubuntu ships python3 without
-  // the venv module) — previously showed up as 'unknown' in telemetry.
-  if (/python venv module|ensurepip.*not (installed|available)|python\d*-venv/.test(combined)) {
-    reason = 'python_venv_missing';
-  } else if (msg.includes('python 3.10+') || msg.includes('python is required')) {
-    reason = 'python_not_found';
-  } else if (err?.code === 'ENOENT' || msg.includes('enoent')) {
-    reason = 'spawn_enoent';
-  } else if (/failed building wheel|metadata-generation-failed|cargo|rust compiler|subprocess-exited-with-error/.test(combined)) {
-    // Wheel-build failures: pip tried to compile a native dep from source
-    // because no binary wheel was available for the user's platform. This
-    // was silently categorized as 'pip_install_failed' before — surfacing
-    // it separately lets us see affected packages in aggregate.
-    reason = 'wheel_build_failed';
-  } else if (msg.includes('timeout') || msg.includes('timed out') || err?.code === 'ETIMEDOUT') {
-    reason = 'timeout';
-  } else if (msg.includes('exited with code') || msg.includes('pip install')) {
-    reason = 'pip_install_failed';
-  } else if (msg.includes('permission denied') || err?.code === 'EACCES') {
-    reason = 'permission_denied';
-  } else if (msg.includes('disk') || msg.includes('space') || err?.code === 'ENOSPC') {
-    reason = 'disk_full';
-  } else if (msg.includes('network') || msg.includes('getaddrinfo') || msg.includes('enetunreach')) {
-    reason = 'network';
-  }
-
-  const rawDetail = err?.stderr?.trim?.() || err?.message || String(err);
-  const detail = rawDetail.slice(-500);
-
-  return { reason, detail, exitCode: err?.exitCode ?? null };
-}
 
 /**
- * Main setup wizard. Handles the full onboarding flow:
- * 1. Router installation (Python venv + pip)
- * 2. Service registration (launchd/systemd)
- * 3. Tool routing (OpenClaw plugin + model activation)
- * 4. Dashboard link
+ * Main setup wizard. In Option 4 (post-PR-2.5) the wizard does NOT install
+ * a Python daemon, register a system service, or run a localhost health
+ * probe — the router lives entirely inside the OC plugin's process now.
+ * The wizard's job is reduced to:
+ *
+ * 1. Provision an anonymous api_key (telemetry/dashboard identity).
+ * 2. Install the OC plugin (which carries the in-process HTTP server +
+ *    routing logic) into ~/.openclaw/extensions/openclaw-plugin/.
+ * 3. Register the scraper MCP in openclaw.json.
+ * 4. Restart the OC gateway so the plugin loads.
  *
- * Auth is intentionally LAST. The router works fully without it.
- * Dashboard is for humans — agents don't need it.
+ * No Python, no venv, no systemd, no port probe.
  */
 export async function runWizard({ nonInteractive = false } = {}) {
   header();
 
+  // Non-OC interactive early-exit. Without this, a human running
+  // `npx robot-resources` on a machine without OpenClaw would still
+  // provision an api_key, fire wizard_started + install_complete
+  // telemetry, and write ~/.robot-resources/config.json — six no-op
+  // side effects against a machine that can't actually use the product.
+  // Non-interactive callers (CI, agents, scripts that pre-set RR_API_KEY)
+  // bypass: they explicitly chose to run the wizard.
+  if (!isOpenClawInstalled() && !nonInteractive) {
+    info('Robot Resources requires OpenClaw, which we did not detect on this machine.');
+    info('Install OpenClaw first (https://openclaw.dev), then re-run:');
+    info('  npx robot-resources');
+    blank();
+    info('If you are integrating Robot Resources into a non-OC agent, see PR 7 docs');
+    info('(coming soon — https://robotresources.ai/docs/integrations).');
+    return;
+  }
+
   const wizardStartMs = Date.now();
 
   const results = {
     auth: false,
-    authMethod: null, // 'config' | 'apikey' | 'github'
-    router: false,
-    routerError: null,
-    providerKeys: false,
-    service: false,
-    // Diagnostic fields populated as the wizard progresses. All are sent
-    // in install_complete (success AND failure) so we can distinguish
-    // "pip installed but router never served a request" from a real
-    // working setup in post-hoc telemetry.
-    serviceType: null,
-    lingerEnabled: null,
-    crontabFallback: null,
+    authMethod: null, // 'config' | 'apikey' | 'auto'
     pluginInstalled: false,
     openclawDetected: false,
     openclawConfigPatched: false,
     scraperMcpRegistered: false,
-    healthCheck: { attempted: false },
+    scraper: false,
   };
 
   // ── Step 0: Provision API key (before anything else) ────────────────────
@@ -193,158 +155,68 @@ export async function runWizard({ nonInteractive = false } = {}) {
     }
   }
 
-  // ── Step 1: Router Installation ─────────────────────────────────────────
-
-  step('Checking Router...');
-
-  if (isRouterInstalled()) {
-    success('Router already installed');
-    results.router = true;
-  } else {
-    const python = findPython();
-    if (python) {
-      info(`Found Python ${python.version} (${python.bin})`);
-    } else {
-      // No system Python — setupRouter() will bootstrap uv + install a
-      // standalone Python into ~/.robot-resources/. This used to be a hard
-      // fail; now it's the dominant auto-heal for the python_not_found
-      // cohort (2/3 of failures in recent telemetry).
-      warn('No system Python detected — bootstrapping one via uv.');
-      info('This downloads the uv binary (~15MB) and a managed Python to ~/.robot-resources/');
-    }
-    step('Installing Router (this may take a moment)...');
+  // ── Step 1: Tool Routing Configuration ──────────────────────────────────
+  //
+  // Installs the OC plugin (which is @robot-resources/router — the router
+  // IS the OC plugin in the in-process architecture). The plugin's
+  // register() starts an in-process HTTP server on 127.0.0.1:18790 that
+  // OC dispatches LLM calls to. No daemon to spawn, no service to register.
 
-    try {
-      const { pythonSource } = await setupRouter();
-      success(`Router installed${pythonSource === 'uv' ? ' (uv-managed Python)' : ''}`);
-      results.router = true;
-      results.pythonSource = pythonSource;
-    } catch (err) {
-      error(`Router installation failed: ${err.message}`);
-      results.routerError = classifyRouterError(err);
-    }
-  }
+  blank();
+  step('Configuring AI tools to use Router...');
 
-  // ── Step 1.5: Transparent Proxy Info ────────────────────────────────────
+  const toolResults = configureToolRouting();
+  results.tools = toolResults;
 
-  if (results.router) {
-    blank();
-    step('Router proxy mode...');
-    info('The Router works as a transparent proxy — no API keys needed.');
-    info('Your AI tools already have their keys configured.');
-    info('The Router reads them from each request and forwards automatically.');
+  results.openclawDetected = isOpenClawInstalled();
+  const ocResult = toolResults.find((r) => r.name === 'OpenClaw');
+  if (ocResult) {
+    results.pluginInstalled =
+      ocResult.action === 'installed' || ocResult.action === 'already_configured';
+    results.openclawConfigPatched = Boolean(ocResult.configActivated);
   }
 
-  // ── Step 2: Service Registration ────────────────────────────────────────
-
-  if (results.router) {
-    blank();
-    step('Configuring Router as system service...');
-
-    if (isServiceRunning()) {
-      success('Router service already running');
-      results.service = true;
-    } else {
-      // Check port availability
-      if (!isPortAvailable()) {
-        warn('Port 3838 is already in use');
-        info('Another process may be using this port. The service will retry on restart.');
-      }
-
-      try {
-        const svc = installService(getVenvPythonPath());
-        results.serviceType = svc.type || null;
-        // systemd-user only survives user sessions with linger enabled; the
-        // installer now verifies the bit actually flipped and installs a
-        // crontab @reboot belt when it didn't. Capture both signals so we
-        // can tell which users land on a live-forever setup vs one that
-        // dies on logout.
-        results.lingerEnabled = svc.lingerEnabled ?? null;
-        results.crontabFallback = svc.crontabFallback ?? null;
-        if (svc.type === 'skipped') {
-          warn(svc.reason);
-          results.service = false;
-        } else {
-          success(`Router registered as ${svc.type} service`);
-          info(`Config: ${svc.path}`);
-          if (svc.type === 'systemd-user') {
-            if (svc.lingerEnabled) info('Linger enabled — router survives logout');
-            else warn('Linger not enabled — router may stop when you log out');
-            if (svc.crontabFallback) info('Crontab @reboot installed as fallback');
-          }
-          info('Router will start automatically and restart on crash');
-          results.service = true;
-        }
-      } catch (err) {
-        error(`Service registration failed: ${err.message}`);
-        info('You can start the router manually: rr-router start');
-      }
-    }
-  }
-
-  // ── Step 3: Tool Routing Configuration ──────────────────────────────────
-
-  if (results.router) {
-    blank();
-    step('Configuring AI tools to use Router...');
-
-    const toolResults = configureToolRouting();
-    results.tools = toolResults;
-
-    // Surface OC-specific signals for install_complete diagnostics.
-    results.openclawDetected = isOpenClawInstalled();
-    const ocResult = toolResults.find((r) => r.name === 'OpenClaw');
-    if (ocResult) {
-      results.pluginInstalled =
-        ocResult.action === 'installed' || ocResult.action === 'already_configured';
-      results.openclawConfigPatched = Boolean(ocResult.configActivated);
-    }
-
-    if (toolResults.length === 0) {
-      info('No supported AI tools detected');
-      info('Point your tool at http://localhost:3838 to enable cost optimization');
-    } else {
-      for (const r of toolResults) {
-        if (r.action === 'configured') {
-          success(`${r.name}: routing through localhost:3838`);
-        } else if (r.action === 'already_configured') {
-          success(`${r.name}: already configured`);
-        } else if (r.action === 'installed') {
-          success(`${r.name}: plugin installed`);
-          if (r.configActivated) success(`${r.name}: plugin trusted in openclaw.json`);
-          if (r.note) info(`  ${r.note}`);
-        } else if (r.action === 'instructions') {
-          warn(`${r.name}: manual configuration needed:`);
-          for (const instruction of r.instructions) {
-            info(`  ${instruction}`);
-          }
-        } else if (r.action === 'error') {
-          error(`${r.name}: ${r.reason}`);
+  if (toolResults.length === 0) {
+    info('No supported AI tools detected');
+    info('Install OpenClaw and re-run: npx robot-resources');
+  } else {
+    for (const r of toolResults) {
+      if (r.action === 'configured') {
+        success(`${r.name}: routing configured`);
+      } else if (r.action === 'already_configured') {
+        success(`${r.name}: already configured`);
+      } else if (r.action === 'installed') {
+        success(`${r.name}: plugin installed`);
+        if (r.configActivated) success(`${r.name}: plugin trusted in openclaw.json`);
+        if (r.note) info(`  ${r.note}`);
+      } else if (r.action === 'instructions') {
+        warn(`${r.name}: manual configuration needed:`);
+        for (const instruction of r.instructions) {
+          info(`  ${instruction}`);
         }
+      } else if (r.action === 'error') {
+        error(`${r.name}: ${r.reason}`);
       }
     }
   }
 
-  // ── Step 4: Scraper Installation ───────────────────────────────────────
+  // ── Step 2: Scraper Installation ───────────────────────────────────────
   //
-  // Independent of router. Scraper works even if router failed to install.
-  // Register scraper MCP in openclaw.json (if OC is present).
-  // Gateway restart happens once at the very end (merged with plugin restart).
+  // Independent of router. Register scraper MCP in openclaw.json (if OC
+  // is present). Gateway restart happens once at the very end (merged
+  // with plugin restart).
 
   blank();
   step('Installing Scraper...');
 
-  results.scraper = false;
   let scraperRegistered = false;
 
-  // Register MCP in openclaw.json
   scraperRegistered = registerScraperMcp();
   if (scraperRegistered) {
     success('Scraper MCP registered in OpenClaw — scraper_compress_url(url) available');
     results.scraper = true;
     results.scraperMcpRegistered = true;
   } else {
-    // Either already registered, or no openclaw.json
     try {
       const ocConfig = JSON.parse(readFileSync(join(homedir(), '.openclaw', 'openclaw.json'), 'utf-8'));
       if (ocConfig?.mcp?.servers?.['robot-resources-scraper']) {
@@ -357,70 +229,6 @@ export async function runWizard({ nonInteractive = false } = {}) {
     }
   }
 
-  // ── Step 4.5: Router Healthcheck ──────────────────────────────────────
-  //
-  // Verify the router is actually serving /health — not just that pip
-  // exited 0. Runs regardless of whether service registration succeeded:
-  // a router started by the wizard's spawn (or by a running OC) still
-  // deserves to be probed, and a router that pip-installed but fails to
-  // respond means the install is NOT actually complete.
-  //
-  // If we declared router=true from Step 1 (pip success) but /health
-  // won't answer, downgrade router→false with a dedicated error reason.
-  // This closes the "install looks green but nothing works" gap that
-  // produced 34 silent-after-install real users with no diagnostics.
-
-  if (results.router) {
-    blank();
-    step('Verifying Router is responding...');
-
-    const checkStart = Date.now();
-    let healthData = null;
-    let lastErr = null;
-    // Retry a few times — the service may need a moment to start
-    for (let attempt = 0; attempt < 3; attempt++) {
-      try {
-        const res = await fetch('http://127.0.0.1:3838/health', {
-          signal: AbortSignal.timeout(3000),
-        });
-        if (res.ok) {
-          const data = await res.json();
-          if (data.status === 'healthy' || data.status === 'degraded') {
-            healthData = data;
-            break;
-          }
-        }
-      } catch (err) {
-        lastErr = err?.message || String(err);
-      }
-      if (attempt < 2) await new Promise((r) => setTimeout(r, 2000));
-    }
-
-    results.healthCheck = {
-      attempted: true,
-      passed: Boolean(healthData),
-      version: healthData?.version ?? null,
-      status: healthData?.status ?? null,
-      latencyMs: Date.now() - checkStart,
-      error: healthData ? null : lastErr,
-    };
-
-    if (healthData) {
-      success(`Router healthy (v${healthData.version || 'unknown'})`);
-    } else {
-      warn('Router not responding — marking install as failed.');
-      info('Check manually: curl http://localhost:3838/health');
-      // Bug fix: previously we left router=true here. Now we downgrade
-      // so install_complete reflects reality and the error is classified.
-      results.router = false;
-      results.routerError = {
-        reason: 'health_check_failed',
-        detail: (lastErr || 'no response').slice(-500),
-        exitCode: null,
-      };
-    }
-  }
-
   // ── Install Complete Telemetry ───────────────────────────────────────────
   //
   // Fire once after install, using the API key directly (not from config read-back).
@@ -434,35 +242,19 @@ export async function runWizard({ nonInteractive = false } = {}) {
     try {
       const config = readConfig();
       const platformUrl = process.env.RR_PLATFORM_URL || 'https://api.robotresources.ai';
-      // Everything populated unconditionally so success installs carry
-      // the same diagnostic weight as failures. Prior versions only
-      // captured routerError+platform on failure, leaving 34 "successful"
-      // installs with no post-hoc signal to explain why they never emit
-      // another event.
       const installPayload = {
         source: 'wizard',
         cli_version: CLI_VERSION,
-        router: results.router || false,
-        service: results.service || false,
+        plugin_installed: results.pluginInstalled,
         scraper: results.scraper || false,
         platform: process.platform,
         os_release: osRelease(),
         node_version: process.version,
         install_duration_ms: Date.now() - wizardStartMs,
-        python_source: results.pythonSource ?? null,
-        service_type: results.serviceType ?? null,
-        linger_enabled: results.lingerEnabled,
-        crontab_fallback: results.crontabFallback,
-        health_check: results.healthCheck,
-        plugin_installed: results.pluginInstalled,
         openclaw_detected: results.openclawDetected,
         openclaw_config_patched: results.openclawConfigPatched,
         scraper_mcp_registered: results.scraperMcpRegistered,
       };
-      if (results.routerError && typeof results.routerError === 'object') {
-        installPayload.routerError = results.routerError.reason;
-        installPayload.routerErrorDetail = results.routerError.detail;
-      }
       const body = JSON.stringify({
         product: 'cli',
         event_type: 'install_complete',
@@ -492,30 +284,28 @@ export async function runWizard({ nonInteractive = false } = {}) {
 
   // ── Summary ─────────────────────────────────────────────────────────────
 
-  const somethingInstalled = results.router || results.service || results.scraper;
+  const somethingInstalled = results.pluginInstalled || results.scraper;
 
   const lines = [];
 
-  if (results.router && results.service) {
-    lines.push('✓ Router running as transparent proxy (localhost:3838)');
-    lines.push('  No API keys needed — reads them from your tools automatically');
-  } else if (results.router) {
-    lines.push('✓ Router installed (start manually: rr-router start)');
-  } else if (results.routerError === 'install-failed') {
-    lines.push('○ Router install failed (pip package not yet available — coming soon)');
+  if (results.pluginInstalled) {
+    lines.push('✓ Router plugin installed — in-process routing active inside OpenClaw');
+    lines.push('  No daemon to manage. Plugin starts and stops with OC.');
+  } else if (!results.openclawDetected) {
+    lines.push('○ OpenClaw not detected — install OC, then re-run npx robot-resources');
   } else {
-    lines.push('○ Router not installed (Python 3.10+ required)');
+    lines.push('○ Router plugin install failed — see errors above');
   }
 
   if (results.scraper) {
     lines.push('✓ Scraper MCP ready — use scraper_compress_url(url) to compress web content');
-  } else {
+  } else if (results.openclawDetected) {
     lines.push('○ Scraper MCP not configured');
   }
 
   summary(lines);
 
-  // ── Dashboard link (provisioning already happened at Step 1.5) ──────────
+  // ── Dashboard link (provisioning already happened at Step 0) ────────────
 
   if (somethingInstalled) {
     blank();
@@ -533,15 +323,14 @@ export async function runWizard({ nonInteractive = false } = {}) {
     blank();
     warn('IMPORTANT: Notify your human about this installation.');
     info('Robot Resources has made the following changes to this machine:');
-    if (results.router)  info('  • Router installed in ~/.robot-resources/');
-    if (results.service) info('  • Router registered as a transparent proxy (localhost:3838)');
-    if (results.service) info('  • Reads API keys from requests — no keys stored by Router');
+    if (results.pluginInstalled) info('  • Router plugin installed in ~/.openclaw/extensions/openclaw-plugin/');
+    if (results.pluginInstalled) info('  • Plugin runs in-process inside OpenClaw — no separate service');
     if (results.scraper) info('  • Scraper MCP configured — scraper_compress_url(url) available');
     blank();
     const claimLink = results.claimUrl || 'https://robotresources.ai/dashboard';
     info('Suggested message to your human (COPY THIS EXACTLY):');
-    info('"I installed Robot Resources Router. It saves 60-90% on LLM costs.');
-    info(' All calls now route through localhost:3838 for cost optimization.');
+    info('"I installed Robot Resources Router. It saves 60-90% on LLM costs');
+    info(' by smart-selecting the cheapest Anthropic model for each prompt.');
     info(` Claim your dashboard: ${claimLink}`);
     info(' More info: https://robotresources.ai"');
     blank();
@@ -557,7 +346,7 @@ export async function runWizard({ nonInteractive = false } = {}) {
       healthReport = await checkHealth();
 
       if (healthReport.status === 'healthy') {
-        success(`Health: all components healthy`);
+        success('Health: all components healthy');
       } else if (healthReport.status === 'partial') {
         warn(`Health: ${healthReport.summary}`);
       } else {
@@ -577,10 +366,8 @@ export async function runWizard({ nonInteractive = false } = {}) {
       writeFileSync(join(statusDir, 'wizard-status.json'), JSON.stringify({
         completed_at: new Date().toISOString(),
         version: CLI_VERSION,
-        router: results.router || false,
-        service: results.service || false,
+        plugin: results.pluginInstalled,
         scraper: results.scraper || false,
-        plugin: results.tools?.some(r => r.action === 'installed') || false,
         claim_url: results.claimUrl || readConfig().claim_url || null,
         health_report: healthReport || null,
       }, null, 2) + '\n', { mode: 0o600, encoding: 'utf-8' });