robot-resources 1.7.0 → 1.7.2

package/README.md

@@ -1,73 +1,105 @@
-# robot-resources — Unified Installer
+# Robot Resources
 
-One command to install all Robot Resources tools:
+> Tools for AI agents. Humans have HR. Agents have RR.
 
-```
+Robot Resources builds tools for AI agents and any software that makes LLM API calls — chatbots, RAG pipelines, AI-powered apps, internal tools. Two products today: **Router** (intelligent model routing, 60-90% cost savings) and **Scraper** (token compression for web content, median 91% token reduction). Both run locally, both free.
+
+## Quick Start
+
+```bash
 npx robot-resources
 ```
 
-## What the wizard does
-
-1. **GitHub OAuth** — authenticates via PKCE, saves API key to `~/.robot-resources/config.json`
-2. **Router install** — detects Python 3.10+, creates venv, pip installs `robot-resources-router`
-3. **Service registration** — registers router as launchd (macOS) or systemd (Linux) service
-4. **Scraper** — installs @robot-resources/scraper for token-efficient web compression
+One command: authenticates via GitHub OAuth, installs Router as an always-on service, registers Scraper as the default web compression tool, and configures your agent automatically.
 
-## Adding a new tool
+## Products
 
-When you build a new product for RR, follow this checklist:
+### Router
 
-### 1. Create the npx entry point
+Intelligent LLM routing proxy. Classifies each prompt by task type, filters by model capability, routes to the cheapest model that qualifies.
 
-Your tool needs an npm package with a `bin` entry that runs a setup wizard. Two patterns:
+- Hybrid classification: keyword detection (~5ms) + LLM fallback for ambiguous prompts (~200ms)
+- Dynamic thresholds: simple tasks open cheap models (0.60), complex tasks require top models (0.85)
+- 11 models across OpenAI, Anthropic, and Google — routes within your available providers
+- 60-90% cost savings with zero quality loss
+- OpenAI-compatible API on localhost:3838 — change your base_url and you're done
+- OpenClaw compatible — plugin auto-installs, works with API keys and subscriptions
 
-- **Node.js tool:** Add `bin` to your package.json pointing to a setup script
-- **Python tool:** Create a thin npm wrapper (like `router/packages/router/`) that handles pip install
+```bash
+npx @robot-resources/router
+```
 
-The wizard should:
-- Check `~/.robot-resources/config.json` — offer login if missing
-- Install the tool
-- Configure MCP if applicable
-- Print usage instructions
+### Scraper
 
-### 2. Update the unified wizard
+Token compression for web content. Fetches any URL, strips noise, returns clean markdown with token count.
 
-Edit `packages/cli/lib/wizard.js` to add your tool as a new step between service registration and MCP config.
+- Mozilla Readability extraction (0.97 F1 accuracy)
+- Content-aware token estimation (±15% of actual BPE)
+- 3-tier fetch: fast, stealth (TLS fingerprint), render (headless browser)
+- Multi-page BFS crawl with robots.txt compliance
+- Median 91% token reduction per page
 
-### 3. Update the landing page
+Installed automatically via `npx robot-resources`. Available as MCP tool `scraper_compress_url(url)` in your agent.
 
-| File | What to change |
-|------|---------------|
-| `web/src/pages/Landing/types.ts` | Add install subsection if new section |
-| `web/src/pages/Landing/components/ContentPanel/animatedContentScreens.ts` | Add install screen (desktop + mobile) |
-| `web/src/pages/Landing/components/TerminalPanel/terminalCommands.ts` | Add install subcommand output |
+### Dashboard
 
-### 4. Update agent-facing content
+Usage dashboard with real-time telemetry. Auth via GitHub OAuth, KPI panels, routing stats, cost savings tracking. Mobile-responsive.
 
-| File | What to change |
-|------|---------------|
-| `web/public/llms.txt` | Add tool with `npx @robot-resources/<tool>` |
-| `web/public/llms-full.txt` | Add detailed section with npx install |
-| `web/public/.well-known/ai-resources.json` | Add SoftwareApplication entry with InstallAction |
+### MCP Servers
 
-### 5. Update the publish workflow
+Both products include MCP servers for AI agent integration:
 
-Add your package.json path to `.github/workflows/publish.yml` triggers and add a publish step.
+```bash
+npx -y @robot-resources/router-mcp    # Router stats + config
+npx -y @robot-resources/scraper-mcp   # Scraper compression
+```
 
-### 6. Add to root workspaces
+## Pricing
 
-Add your package directory to the `workspaces` array in the root `package.json`.
+Free. Unlimited. No tiers. Both tools run locally — you pay your AI providers directly. No markup, no rate limits, no quotas. Your API keys never leave your machine.
 
-## Architecture
+## Monorepo Structure
 
 ```
-packages/cli-core/    Shared auth, config, login (private — never published)
-packages/cli/         This package (published as "robot-resources" on npm)
-  bin/setup.js        Entry point
-  lib/wizard.js       Orchestrator — add new tools here
-  lib/service.js      launchd + systemd service registration
-  lib/python-bridge.js  Python venv management
-  lib/detect.js       Environment detection
-  lib/tool-config.js  OpenClaw plugin + model activation
-  lib/ui.js           Terminal formatting
+robot-resources/
+├── router/         # LLM routing proxy (Python + TypeScript MCP)
+├── scraper/        # Token compression (TypeScript)
+├── web/            # Landing page + dashboard (React/Vite)
+├── platform/       # Backend API — auth, telemetry (Hono/Cloudflare Workers)
+├── packages/       # Unified CLI installer (npx robot-resources)
+├── skills/         # Agent skills (ClawHub)
+├── _orchestrator/  # Business coordination
+└── _brand/         # Brand assets and design system
 ```
+
+## Development
+
+Each product has its own setup:
+
+- [Router](./router/README.md)
+- [Scraper](./scraper/packages/scraper/README.md)
+- [Platform](./platform/README.md)
+- [CLI](./packages/cli/README.md)
+
+## CI/CD
+
+Unified pipeline on push/PR to main:
+
+- **Router**: ruff, mypy, pytest
+- **Scraper**: tsc, vitest
+- **Web**: tsc, eslint
+- **Publish**: 7 npm packages via OIDC (`router`, `router-mcp`, `scraper`, `scraper-mcp`, `scraper-tracking`, `cli-core`, `cli`)
+
+## Links
+
+- Website: https://robotresources.ai
+- GitHub: https://github.com/robot-resources
+- npm: `npx robot-resources`
+- Twitter/X: https://x.com/robotresources
+- Discord: https://robotresources.ai/discord
+- Contact: agent@robotresources.ai
+- Agent docs: https://robotresources.ai/llms.txt
+
+## License
+
+MIT

package/lib/health-report.js

@@ -0,0 +1,124 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { readConfig } from '@robot-resources/cli-core/config.mjs';
+
+const PROBE_TIMEOUT_MS = 5_000;
+
+/**
+ * Run post-install health checks against all Robot Resources components.
+ *
+ * Probes:
+ *  1. Router   — GET http://127.0.0.1:3838/health
+ *  2. Scraper  — check openclaw.json for scraper MCP registration
+ *  3. Platform — GET {platformUrl}/v1/health with api_key
+ *  4. MCP      — check openclaw.json for openclaw-plugin registration
+ *
+ * @returns {{ status: 'healthy'|'partial'|'failed', components: Object, summary: string }}
+ */
+export async function checkHealth() {
+  const config = readConfig();
+
+  const [router, scraper, platform, mcp] = await Promise.all([
+    probeRouter(),
+    probeScraper(),
+    probePlatform(config),
+    probeMcp(),
+  ]);
+
+  const components = { router, scraper, platform, mcp };
+  const healthyCount = Object.values(components).filter((c) => c.healthy).length;
+  const total = Object.keys(components).length;
+
+  let status;
+  if (healthyCount === total) {
+    status = 'healthy';
+  } else if (healthyCount === 0) {
+    status = 'failed';
+  } else {
+    status = 'partial';
+  }
+
+  const failing = Object.entries(components)
+    .filter(([, c]) => !c.healthy)
+    .map(([name, c]) => `${name}: ${c.detail}`);
+
+  const summary =
+    status === 'healthy'
+      ? `All ${total} components healthy.`
+      : `${healthyCount}/${total} healthy. Issues: ${failing.join('; ')}`;
+
+  return { status, components, summary };
+}
+
+async function probeRouter() {
+  try {
+    if (typeof fetch === 'undefined') {
+      return { healthy: false, detail: 'fetch unavailable' };
+    }
+    const res = await fetch('http://127.0.0.1:3838/health', {
+      signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
+    });
+    if (!res.ok) {
+      return { healthy: false, detail: `HTTP ${res.status}` };
+    }
+    const data = await res.json();
+    if (data.status === 'healthy' || data.status === 'degraded') {
+      return { healthy: true, detail: `running (v${data.version || 'unknown'})` };
+    }
+    return { healthy: false, detail: `status: ${data.status}` };
+  } catch (err) {
+    const detail = err.name === 'AbortError' ? 'timeout' : 'unreachable';
+    return { healthy: false, detail };
+  }
+}
+
+function probeScraper() {
+  try {
+    const ocPath = join(homedir(), '.openclaw', 'openclaw.json');
+    const ocConfig = JSON.parse(readFileSync(ocPath, 'utf-8'));
+    const hasServer = !!ocConfig?.mcp?.servers?.['robot-resources-scraper'];
+    return {
+      healthy: hasServer,
+      detail: hasServer ? 'MCP registered' : 'scraper MCP not registered',
+    };
+  } catch {
+    return { healthy: false, detail: 'openclaw.json not found' };
+  }
+}
+
+async function probePlatform(config) {
+  if (!config.api_key) {
+    return { healthy: false, detail: 'no API key configured' };
+  }
+  try {
+    if (typeof fetch === 'undefined') {
+      return { healthy: false, detail: 'fetch unavailable' };
+    }
+    const platformUrl = process.env.RR_PLATFORM_URL || 'https://api.robotresources.ai';
+    const res = await fetch(`${platformUrl}/health`, {
+      signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
+    });
+    return {
+      healthy: res.ok,
+      detail: res.ok ? 'reachable' : `HTTP ${res.status}`,
+    };
+  } catch (err) {
+    const detail = err.name === 'AbortError' ? 'timeout' : 'unreachable';
+    return { healthy: false, detail };
+  }
+}
+
+function probeMcp() {
+  try {
+    const ocPath = join(homedir(), '.openclaw', 'openclaw.json');
+    const ocConfig = JSON.parse(readFileSync(ocPath, 'utf-8'));
+    const hasPlugin = !!ocConfig?.plugins?.entries?.['openclaw-plugin']?.enabled;
+    return {
+      healthy: hasPlugin,
+      detail: hasPlugin ? 'plugin registered' : 'openclaw-plugin not registered',
+    };
+  } catch {
+    return { healthy: false, detail: 'openclaw.json not found' };
+  }
+}

package/lib/machine-id.js

@@ -0,0 +1,31 @@
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+
+/**
+ * Reads or creates a persistent machine identifier.
+ * Used for telemetry deduplication across sessions.
+ *
+ * @param {string} [configDir] - Directory to store .machine-id (defaults to ~/.robot-resources)
+ * @returns {string} A UUID v4 machine identifier
+ */
+export function getOrCreateMachineId(configDir) {
+  const dir = configDir ?? join(homedir(), '.robot-resources');
+  const machineIdPath = join(dir, '.machine-id');
+
+  try {
+    const stored = readFileSync(machineIdPath, 'utf-8').trim();
+    if (stored) return stored;
+  } catch {
+    // File doesn't exist or can't be read — fall through to generate
+  }
+
+  const machineId = randomUUID();
+  try {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(machineIdPath, machineId, 'utf-8');
+  } catch { /* non-fatal */ }
+
+  return machineId;
+}

package/lib/tool-config.js

@@ -1,15 +1,19 @@
 import { spawn } from 'node:child_process';
 import { createRequire } from 'node:module';
-import { readFileSync, writeFileSync, copyFileSync, mkdirSync } from 'node:fs';
+import { readFileSync, writeFileSync, copyFileSync, mkdirSync, existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
 import { isOpenClawInstalled, isOpenClawPluginInstalled, getOpenClawAuthMode } from './detect.js';
 import { stripJson5 } from './json5.js';
 
+/**
+ * Heartbeat interval in ms. OC kills processes after 5s of no output
+ * (noOutputTimeoutMs = 5000). This must stay under that threshold.
+ */
+const HEARTBEAT_INTERVAL_MS = 4000;
+
 /**
  * Run a command with a heartbeat to keep agent sessions alive.
- * OC kills processes after 5s of no output (noOutputTimeoutMs).
- * Prints immediately, then every 4s (safely under the 5s threshold).
  */
 function spawnWithHeartbeat(cmd, args, { label, timeout = 30_000 } = {}) {
   return new Promise((resolve, reject) => {
@@ -21,9 +25,9 @@ function spawnWithHeartbeat(cmd, args, { label, timeout = 30_000 } = {}) {
     process.stdout.write(`  ${label}...\n`);
     let seconds = 0;
     const heartbeat = setInterval(() => {
-      seconds += 4;
+      seconds += HEARTBEAT_INTERVAL_MS / 1000;
       process.stdout.write(`  ${label}... ${seconds}s\n`);
-    }, 4000);
+    }, HEARTBEAT_INTERVAL_MS);
 
     proc.on('close', (code) => {
       clearInterval(heartbeat);
@@ -39,39 +43,52 @@ function spawnWithHeartbeat(cmd, args, { label, timeout = 30_000 } = {}) {
 }
 
 /**
- * Set robot-resources/auto as the default model in openclaw.json.
+ * Read openclaw.json, creating it with a minimal structure if it doesn't exist.
+ * Returns parsed config object. Throws on malformed JSON (caller handles).
+ */
+function readOrCreateOpenClawConfig() {
+  const configDir = join(homedir(), '.openclaw');
+  const configPath = join(configDir, 'openclaw.json');
+
+  if (!existsSync(configPath)) {
+    mkdirSync(configDir, { recursive: true });
+    const minimal = {};
+    writeFileSync(configPath, JSON.stringify(minimal, null, 2) + '\n', 'utf-8');
+    return minimal;
+  }
+
+  const raw = readFileSync(configPath, 'utf-8');
+  return JSON.parse(stripJson5(raw));
+}
+
+/**
+ * Trust the Robot Resources plugin in OpenClaw config.
  *
- * This is required so the plugin's before_model_resolve hook fires.
- * Without it, OpenClaw sends requests directly to Anthropic and the
- * plugin never gets a chance to route.
+ * Adds "openclaw-plugin" to plugins.allow so OpenClaw loads it without
+ * provenance warnings. The plugin's before_model_resolve hook intercepts
+ * ALL LLM calls regardless of the default model — no need to change the
+ * default model (which causes LiveSessionModelSwitchError in OC).
  *
  * Returns true if the config was updated, false otherwise.
  */
-function activateRouterModel() {
+function trustPlugin() {
   const configPath = join(homedir(), '.openclaw', 'openclaw.json');
 
   try {
-    const raw = readFileSync(configPath, 'utf-8');
-    const config = JSON.parse(stripJson5(raw));
-
-    // Ensure agents.defaults.model exists
-    if (!config.agents) config.agents = {};
-    if (!config.agents.defaults) config.agents.defaults = {};
-    if (!config.agents.defaults.model) config.agents.defaults.model = {};
+    const config = readOrCreateOpenClawConfig();
 
-    const currentPrimary = config.agents.defaults.model.primary;
+    if (!config.plugins) config.plugins = {};
+    if (!Array.isArray(config.plugins.allow)) config.plugins.allow = [];
 
-    // Only change if not already pointing at robot-resources
-    if (currentPrimary && currentPrimary.startsWith('robot-resources/')) {
+    if (config.plugins.allow.includes('openclaw-plugin')) {
       return false;
     }
 
-    config.agents.defaults.model.primary = 'robot-resources/auto';
+    config.plugins.allow.push('openclaw-plugin');
 
     writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
     return true;
   } catch {
-    // Config missing or malformed — non-fatal
     return false;
   }
 }
@@ -89,8 +106,7 @@ function registerScraperMcp() {
   const configPath = join(homedir(), '.openclaw', 'openclaw.json');
 
   try {
-    const raw = readFileSync(configPath, 'utf-8');
-    const config = JSON.parse(stripJson5(raw));
+    const config = readOrCreateOpenClawConfig();
 
     if (!config.mcp) config.mcp = {};
     if (!config.mcp.servers) config.mcp.servers = {};
@@ -141,8 +157,7 @@ function registerPluginEntry() {
   const configPath = join(homedir(), '.openclaw', 'openclaw.json');
 
   try {
-    const raw = readFileSync(configPath, 'utf-8');
-    const config = JSON.parse(stripJson5(raw));
+    const config = readOrCreateOpenClawConfig();
 
     if (!config.plugins) config.plugins = {};
     if (!config.plugins.entries) config.plugins.entries = {};
@@ -188,9 +203,8 @@ function configureOpenClaw() {
     // Register plugin in openclaw.json so OC loads it on gateway start.
     registerPluginEntry();
 
-    // Set robot-resources/auto as the default model so the plugin's
-    // before_model_resolve hook actually fires for every request.
-    const configActivated = activateRouterModel();
+    // Trust the plugin so OC loads it without provenance warnings.
+    const configActivated = trustPlugin();
 
     return {
       name: 'OpenClaw',
@@ -245,13 +259,30 @@ export function configureToolRouting() {
 
 /**
  * Restart the OpenClaw gateway so it picks up new plugin + config.
- * Uses heartbeat to keep OC sessions alive during the restart.
+ * Retries up to 3 times with 2s backoff — gateway restart MUST succeed
+ * for MCP tools to be available. Silent failure = tools broken for user.
  */
 async function restartOpenClawGateway() {
-  await spawnWithHeartbeat('openclaw', ['gateway', 'restart'], {
-    label: 'Restarting gateway',
-    timeout: 15_000,
-  });
+  const MAX_RETRIES = 3;
+  const BACKOFF_MS = 2000;
+  let lastError;
+
+  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      await spawnWithHeartbeat('openclaw', ['gateway', 'restart'], {
+        label: `Restarting gateway${attempt > 1 ? ` (attempt ${attempt}/${MAX_RETRIES})` : ''}`,
+        timeout: 15_000,
+      });
+      return; // success
+    } catch (err) {
+      lastError = err;
+      if (attempt < MAX_RETRIES) {
+        await new Promise(r => setTimeout(r, BACKOFF_MS));
+      }
+    }
+  }
+
+  throw lastError;
 }
 
 // Exported for testing and direct use

package/lib/wizard.js

@@ -1,8 +1,13 @@
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir, hostname } from 'node:os';
 import { readConfig, writeConfig } from '@robot-resources/cli-core/config.mjs';
 import { findPython, isPortAvailable, isHeadless, 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';
 /**
  * Main setup wizard. Handles the full onboarding flow:
@@ -36,24 +41,7 @@ export async function runWizard({ nonInteractive = false } = {}) {
     const config = readConfig();
     if (!config.api_key && !process.env.RR_API_KEY) {
       try {
-        const { hostname } = await import('node:os');
-        const { join } = await import('node:path');
-        const { homedir } = await import('node:os');
-        const { readFileSync, writeFileSync, mkdirSync } = await import('node:fs');
-        const { randomUUID } = await import('node:crypto');
-
-        const rrDir = join(homedir(), '.robot-resources');
-        const machineIdPath = join(rrDir, '.machine-id');
-        let machineId;
-        try {
-          machineId = readFileSync(machineIdPath, 'utf-8').trim();
-        } catch {
-          machineId = randomUUID();
-          try {
-            mkdirSync(rrDir, { recursive: true });
-            writeFileSync(machineIdPath, machineId, 'utf-8');
-          } catch { /* non-fatal */ }
-        }
+        const machineId = getOrCreateMachineId();
 
         const platformUrl = process.env.RR_PLATFORM_URL || 'https://api.robotresources.ai';
         const res = await fetch(`${platformUrl}/v1/auth/signup`, {
@@ -184,7 +172,7 @@ export async function runWizard({ nonInteractive = false } = {}) {
           success(`${r.name}: already configured`);
         } else if (r.action === 'installed') {
           success(`${r.name}: plugin installed`);
-          if (r.configActivated) success(`${r.name}: default model set to robot-resources/auto`);
+          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:`);
@@ -218,10 +206,7 @@ export async function runWizard({ nonInteractive = false } = {}) {
   } else {
     // Either already registered, or no openclaw.json
     try {
-      const { readFileSync: readFs } = await import('node:fs');
-      const { join: joinPath } = await import('node:path');
-      const { homedir: home } = await import('node:os');
-      const ocConfig = JSON.parse(readFs(joinPath(home(), '.openclaw', 'openclaw.json'), 'utf-8'));
+      const ocConfig = JSON.parse(readFileSync(join(homedir(), '.openclaw', 'openclaw.json'), 'utf-8'));
       if (ocConfig?.mcp?.servers?.['robot-resources-scraper']) {
         success('Scraper MCP already registered in OpenClaw');
         results.scraper = true;
@@ -354,17 +339,52 @@ export async function runWizard({ nonInteractive = false } = {}) {
     blank();
   }
 
+  // ── Best-effort: Single gateway restart ────────────────────────────────
+  //
+  // Merged from two previous restarts (after plugin install + after scraper
+  // registration). Everything is already installed and registered above.
+  // If the session dies during this restart, the gateway picks up changes
+  // on its next natural restart.
+
+  if (isOpenClawInstalled() && (results.tools?.some(r => r.action === 'installed') || scraperRegistered)) {
+    try {
+      await restartOpenClawGateway();
+      success('OpenClaw gateway restarted');
+    } catch {
+      warn('Gateway restart failed — tools may not be available until OpenClaw restarts.');
+      warn('Run manually: openclaw gateway restart');
+    }
+  }
+
+  // ── Post-install health check ──────────────────────────────────────────
+
+  let healthReport = null;
+  if (somethingInstalled) {
+    try {
+      blank();
+      step('Running post-install health check...');
+      healthReport = await checkHealth();
+
+      if (healthReport.status === 'healthy') {
+        success(`Health: all components healthy`);
+      } else if (healthReport.status === 'partial') {
+        warn(`Health: ${healthReport.summary}`);
+      } else {
+        error(`Health: ${healthReport.summary}`);
+      }
+    } catch {
+      // Non-fatal — health check is informational
+    }
+  }
+
   // ── Status file (persists results for agents that lose the session) ─────
 
   if (somethingInstalled) {
     try {
-      const { readFileSync: readFs, writeFileSync: writeFs, mkdirSync: mkFs } = await import('node:fs');
-      const { join: joinP } = await import('node:path');
-      const { homedir: homeP } = await import('node:os');
-      const statusDir = joinP(homeP(), '.robot-resources');
-      mkFs(statusDir, { recursive: true });
-      const pkgVersion = JSON.parse(readFs(new URL('../package.json', import.meta.url), 'utf-8')).version;
-      writeFs(joinP(statusDir, 'wizard-status.json'), JSON.stringify({
+      const statusDir = join(homedir(), '.robot-resources');
+      mkdirSync(statusDir, { recursive: true });
+      const pkgVersion = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8')).version;
+      writeFileSync(join(statusDir, 'wizard-status.json'), JSON.stringify({
         completed_at: new Date().toISOString(),
         version: pkgVersion,
         router: results.router || false,
@@ -372,25 +392,10 @@ export async function runWizard({ nonInteractive = false } = {}) {
         scraper: results.scraper || false,
         plugin: results.tools?.some(r => r.action === 'installed') || false,
         claim_url: results.claimUrl || readConfig().claim_url || null,
-      }, null, 2) + '\n', 'utf-8');
+        health_report: healthReport || null,
+      }, null, 2) + '\n', { mode: 0o600, encoding: 'utf-8' });
     } catch {
       // Non-fatal — status file is a convenience, not required
     }
   }
-
-  // ── Best-effort: Single gateway restart ────────────────────────────────
-  //
-  // Merged from two previous restarts (after plugin install + after scraper
-  // registration). Everything is already installed and registered above.
-  // If the session dies during this restart, the gateway picks up changes
-  // on its next natural restart.
-
-  if (isOpenClawInstalled() && (results.tools?.some(r => r.action === 'installed') || scraperRegistered)) {
-    try {
-      await restartOpenClawGateway();
-      success('OpenClaw gateway restarted');
-    } catch {
-      // Best-effort — gateway picks up changes on next restart
-    }
-  }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "robot-resources",
-  "version": "1.7.0",
-  "description": "Robot Resources — AI agent runtime tools. One command to install everything.",
+  "version": "1.7.2",
+  "description": "Robot Resources — AI agent tools. One command to install everything.",
   "type": "module",
   "bin": {
     "robot-resources-setup": "./bin/setup.js"