@robbiesrobotics/alice-agents 1.1.0 → 1.2.0

package/lib/installer.mjs

@@ -1,4 +1,4 @@
-import { readFileSync } from 'node:fs';
+import { readFileSync, existsSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execSync } from 'node:child_process';
@@ -27,6 +27,63 @@ function isOpenClawInstalled() {
   }
 }
 
+function getOpenClawVersion() {
+  try {
+    const output = execSync('openclaw --version', { stdio: 'pipe', encoding: 'utf8' });
+    const match = output.match(/(\d{4}\.\d+\.\d+)/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+
+function getLatestNpmVersion() {
+  try {
+    const output = execSync('npm view openclaw version', { stdio: 'pipe', encoding: 'utf8' });
+    return output.trim();
+  } catch {
+    return null;
+  }
+}
+
+async function checkForOpenClawUpdate(auto) {
+  const current = getOpenClawVersion();
+  if (!current) return;
+
+  console.log(`  OpenClaw version: ${current}`);
+
+  const latest = getLatestNpmVersion();
+  if (!latest) {
+    console.log('  ⚠️  Could not check for updates (npm registry unreachable)\n');
+    return;
+  }
+
+  if (current === latest) {
+    console.log(`  ✓ OpenClaw is up to date (${latest})\n`);
+    return;
+  }
+
+  console.log(`  ⬆️  Update available: ${current} → ${latest}\n`);
+
+  let shouldUpdate = auto;
+  if (!auto) {
+    shouldUpdate = await confirm('  Update OpenClaw to latest before continuing?');
+  }
+
+  if (shouldUpdate) {
+    console.log('  📦 Updating OpenClaw...\n');
+    try {
+      execSync('npm install -g openclaw@latest', { stdio: 'inherit' });
+      const updated = getOpenClawVersion();
+      console.log(`\n  ✓ OpenClaw updated to ${updated || latest}\n`);
+    } catch {
+      console.log('\n  ⚠️  Update failed — continuing with current version\n');
+    }
+  } else {
+    console.log();
+  }
+}
+
 async function installOpenClaw(auto) {
   console.log('  ⚠️  OpenClaw is not installed.\n');
 
@@ -127,6 +184,22 @@ function printSummary(mode, tier, agents, preset, userInfo) {
 export async function runInstall(options = {}) {
   const auto = options.yes || false;
 
+  // Check health flag first (before banner)
+  if (process.argv.includes('--health')) {
+    const healthPath = join(process.env.HOME, '.openclaw', '.alice-health-alert.json');
+    if (existsSync(healthPath)) {
+      const alerts = JSON.parse(readFileSync(healthPath, 'utf8'));
+      console.log('\n⚠️  A.L.I.C.E. Health Report\n');
+      for (const alert of alerts.alerts) {
+        console.log(`  [${alert.severity}] ${alert.category}: ${alert.field}`);
+        console.log(`    ${alert.description}\n`);
+      }
+      process.exit(0);
+    }
+    console.log('✅ A.L.I.C.E. is healthy\n');
+    process.exit(0);
+  }
+
   printBanner();
 
   // 1. Detect OpenClaw — offer to install if missing
@@ -139,6 +212,10 @@ export async function runInstall(options = {}) {
     console.error('  ❌ OpenClaw config not found. Run: openclaw configure\n');
     process.exit(1);
   }
+
+  // 1b. Check for OpenClaw updates
+  await checkForOpenClawUpdate(auto);
+
   console.log('  ✓ OpenClaw detected\n');
 
   const allAgents = loadAgentRegistry();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robbiesrobotics/alice-agents",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "A.L.I.C.E. — 28 AI agents for OpenClaw. One conversation, one team.",
   "bin": {
     "alice-agents": "bin/alice-install.mjs"
@@ -20,7 +20,10 @@
   "files": [
     "bin/",
     "lib/",
+    "tools/",
+    "snapshots/",
     "templates/",
+    "SELF-HEALING-SPEC.md",
     "README.md"
   ],
   "publishConfig": {

package/snapshots/schema-snapshot.json

@@ -0,0 +1,221 @@
+{
+  "meta": {
+    "capturedAt": "2026-03-16T00:00:00Z",
+    "openclawVersion": "2026.3.13",
+    "aliceVersion": "1.1.1",
+    "description": "Config fields A.L.I.C.E. depends on",
+    "checksum": "458186002246ca46"
+  },
+  "agents": {
+    "defaults": {
+      "model": {
+        "path": "agents.defaults.model",
+        "required": true,
+        "fields": {
+          "primary": {
+            "type": "string",
+            "example": "anthropic/claude-sonnet-4-6"
+          },
+          "fallbacks": {
+            "type": "array"
+          }
+        }
+      },
+      "workspace": {
+        "path": "agents.defaults.workspace",
+        "type": "string",
+        "required": true
+      },
+      "heartbeat": {
+        "path": "agents.defaults.heartbeat",
+        "required": false,
+        "fields": {
+          "every": {
+            "type": "string",
+            "example": "15m"
+          },
+          "target": {
+            "type": "string",
+            "allowedValues": [
+              "last",
+              "new"
+            ]
+          },
+          "directPolicy": {
+            "type": "string",
+            "allowedValues": [
+              "allow",
+              "deny"
+            ]
+          },
+          "prompt": {
+            "type": "string"
+          }
+        }
+      },
+      "maxConcurrent": {
+        "path": "agents.defaults.maxConcurrent",
+        "type": "number",
+        "required": false
+      },
+      "subagents": {
+        "path": "agents.defaults.subagents",
+        "fields": {
+          "maxConcurrent": {
+            "type": "number"
+          },
+          "archiveAfterMinutes": {
+            "type": "number"
+          },
+          "runTimeoutSeconds": {
+            "type": "number"
+          }
+        }
+      },
+      "compaction": {
+        "path": "agents.defaults.compaction",
+        "fields": {
+          "mode": {
+            "type": "string",
+            "allowedValues": [
+              "safeguard",
+              "auto",
+              "off"
+            ]
+          }
+        }
+      }
+    },
+    "list_entry": {
+      "description": "Schema for each entry in agents.list",
+      "fields": {
+        "id": {
+          "type": "string",
+          "required": true
+        },
+        "name": {
+          "type": "string",
+          "required": true
+        },
+        "workspace": {
+          "type": "string",
+          "required": true
+        },
+        "identity": {
+          "required": true,
+          "fields": {
+            "name": {
+              "type": "string"
+            },
+            "theme": {
+              "type": "string"
+            },
+            "emoji": {
+              "type": "string"
+            }
+          }
+        },
+        "sandbox": {
+          "required": true,
+          "fields": {
+            "mode": {
+              "type": "string",
+              "allowedValues": [
+                "off",
+                "all"
+              ]
+            },
+            "scope": {
+              "type": "string",
+              "allowedValues": [
+                "agent",
+                "workspace"
+              ]
+            }
+          }
+        },
+        "tools": {
+          "required": true,
+          "variants": {
+            "profile_based": {
+              "fields": {
+                "profile": {
+                  "type": "string",
+                  "allowedValues": [
+                    "full",
+                    "coding",
+                    "basic"
+                  ]
+                },
+                "alsoAllow": {
+                  "type": "array"
+                },
+                "deny": {
+                  "type": "array"
+                }
+              }
+            },
+            "explicit": {
+              "fields": {
+                "allow": {
+                  "type": "array",
+                  "required": true
+                },
+                "deny": {
+                  "type": "array"
+                }
+              }
+            }
+          }
+        },
+        "model": {
+          "type": "string",
+          "required": false
+        },
+        "default": {
+          "type": "boolean",
+          "required": false
+        },
+        "subagents": {
+          "type": "object",
+          "required": false
+        },
+        "groupChat": {
+          "type": "object",
+          "required": false
+        }
+      }
+    }
+  },
+  "tools": {
+    "agentToAgent": {
+      "path": "tools.agentToAgent",
+      "fields": {
+        "allow": {
+          "type": "array",
+          "description": "Agent IDs that can receive spawned tasks"
+        }
+      }
+    }
+  },
+  "hooks": {
+    "knownHooks": [
+      "boot-md",
+      "bootstrap-extra-files",
+      "command-logger",
+      "session-memory"
+    ],
+    "path": "hooks.entries"
+  },
+  "sessions": {
+    "path": "sessions",
+    "fields": {
+      "plugins": {
+        "type": "object"
+      },
+      "capabilities": {
+        "type": "object"
+      }
+    }
+  }
+}

package/snapshots/tool-snapshot.json

@@ -0,0 +1,37 @@
+{
+  "meta": {
+    "capturedAt": "2026-03-16T00:00:00Z",
+    "openclawVersion": "2026.3.13",
+    "aliceVersion": "1.1.1",
+    "description": "Tools A.L.I.C.E. references in agent configs"
+  },
+  "tools": {
+    "read":            { "criticality": "core",     "usedBy": ["all"] },
+    "write":           { "criticality": "core",     "usedBy": ["all"] },
+    "edit":            { "criticality": "core",     "usedBy": ["dylan","darius","avery","isaac","felix","caleb","devon","quinn","alex","daphne"] },
+    "exec":            { "criticality": "core",     "usedBy": ["dylan","darius","avery","isaac","owen","selena","devon","quinn","alex","felix","caleb"] },
+    "process":         { "criticality": "core",     "usedBy": ["dylan","darius","avery","isaac","devon","quinn"] },
+    "apply_patch":     { "criticality": "core",     "usedBy": ["dylan","darius","avery","isaac","felix","caleb","devon","quinn","alex","daphne"] },
+    "web_search":      { "criticality": "core",     "usedBy": ["all"] },
+    "web_fetch":       { "criticality": "core",     "usedBy": ["all"] },
+    "browser":         { "criticality": "optional", "usedBy": ["olivia","rowan","quinn","uma","alex","tommy","nadia","morgan","sloane"] },
+    "canvas":          { "criticality": "optional", "usedBy": ["olivia","nadia"] },
+    "message":         { "criticality": "optional", "usedBy": ["olivia","clara","sophie","sloane","morgan","eva","parker"] },
+    "tts":             { "criticality": "optional", "usedBy": ["olivia"] },
+    "sessions_spawn":  { "criticality": "core",     "usedBy": ["olivia"] },
+    "sessions_send":   { "criticality": "core",     "usedBy": ["olivia"] },
+    "sessions_list":   { "criticality": "core",     "usedBy": ["olivia","all"] },
+    "sessions_history":{ "criticality": "core",     "usedBy": ["olivia","all"] },
+    "session_status":  { "criticality": "core",     "usedBy": ["olivia","all"] },
+    "agents_list":     { "criticality": "core",     "usedBy": ["olivia"] },
+    "cron":            { "criticality": "optional", "usedBy": ["olivia","avery","tommy","sloane","morgan","eva","parker"] },
+    "memory_search":   { "criticality": "core",     "usedBy": ["olivia"] },
+    "memory_get":      { "criticality": "core",     "usedBy": ["olivia"] },
+    "image":           { "criticality": "optional", "usedBy": ["olivia"] },
+    "pdf":             { "criticality": "optional", "usedBy": ["olivia"] }
+  },
+  "profiles": {
+    "full":   { "description": "All tools available", "usedBy": ["olivia"] },
+    "coding": { "description": "Code-focused toolset with exec/edit/apply_patch", "usedBy": ["dylan","darius","avery","isaac","devon","felix","quinn","alex","caleb"] }
+  }
+}

package/tools/compatibility-checker.mjs

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+/**
+ * A.L.I.C.E. Compatibility Checker
+ * Diffs current OpenClaw installation against stored snapshots.
+ * Exit 0 = compatible, 1 = breaking changes found.
+ */
+
+import { readFileSync, existsSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(__dirname, '..');
+
+// --- CLI args ---
+const args = process.argv.slice(2);
+const verbose = args.includes('--verbose');
+const outputFile = args.find(a => a.startsWith('--output='))?.split('=')[1];
+
+function log(...a) { if (verbose) console.log(...a); }
+function warn(msg) { console.warn(`  ⚠️  ${msg}`); }
+
+// --- Helpers ---
+function loadJSON(path) {
+  if (!existsSync(path)) return null;
+  return JSON.parse(readFileSync(path, 'utf8'));
+}
+
+function getOpenClawVersion() {
+  try {
+    const out = execSync('openclaw --version 2>/dev/null', { encoding: 'utf8', stdio: ['pipe','pipe','pipe'] });
+    const m = out.match(/(\d{4}\.\d+\.\d+)/);
+    return m ? m[1] : 'unknown';
+  } catch { return 'unknown'; }
+}
+
+function getOpenClawConfig() {
+  const configPath = join(process.env.HOME, '.openclaw', 'openclaw.json');
+  return loadJSON(configPath);
+}
+
+// --- Diff functions ---
+
+function diffConfigSchema(snapshot, liveConfig) {
+  const changes = [];
+
+  // Check agents.defaults fields
+  const defaults = liveConfig?.agents?.defaults || {};
+  const snap = snapshot?.agents?.defaults || {};
+
+  if (!defaults.model?.primary) {
+    changes.push({
+      category: 'config',
+      severity: 'high',
+      field: 'agents.defaults.model.primary',
+      change: 'Field missing or undefined',
+      autoFixable: false
+    });
+  }
+
+  // Check sandbox allowedValues
+  const agents = liveConfig?.agents?.list || [];
+  for (const agent of agents) {
+    const mode = agent?.sandbox?.mode;
+    const allowed = ['off', 'all'];
+    if (mode && !allowed.includes(mode)) {
+      changes.push({
+        category: 'config',
+        severity: 'high',
+        field: `agents.list[${agent.id}].sandbox.mode`,
+        change: `Unexpected value '${mode}', expected one of: ${allowed.join(', ')}`,
+        autoFixable: false
+      });
+    }
+  }
+
+  // Check compaction mode
+  const compactionMode = defaults?.compaction?.mode;
+  const validModes = ['safeguard', 'auto', 'off'];
+  if (compactionMode && !validModes.includes(compactionMode)) {
+    changes.push({
+      category: 'behavioral',
+      severity: 'medium',
+      field: 'agents.defaults.compaction.mode',
+      change: `Value '${compactionMode}' may not be valid. Expected: ${validModes.join(', ')}`,
+      autoFixable: false
+    });
+  }
+
+  return changes;
+}
+
+function diffToolAPI(snapshot, liveConfig) {
+  const changes = [];
+  const snapTools = snapshot?.tools || {};
+
+  // Get all tools referenced in agent configs
+  const referencedTools = new Set();
+  const referencedProfiles = new Set();
+
+  for (const agent of liveConfig?.agents?.list || []) {
+    const t = agent?.tools || {};
+    if (t.profile) referencedProfiles.add(t.profile);
+    for (const tool of [...(t.allow || []), ...(t.alsoAllow || []), ...(t.deny || [])]) {
+      referencedTools.add(tool);
+    }
+  }
+
+  const knownTools = new Set(Object.keys(snapTools));
+
+  // Check for tools in use that aren't in our snapshot (may be new — not breaking)
+  for (const tool of referencedTools) {
+    if (!knownTools.has(tool)) {
+      log(`  Note: Tool '${tool}' not in snapshot — may be new`);
+    }
+  }
+
+  // Check snapshot profiles still exist
+  const snapProfiles = snapshot?.profiles || {};
+  for (const profile of referencedProfiles) {
+    if (!snapProfiles[profile]) {
+      // Can't verify, just note
+      log(`  Note: Profile '${profile}' used but not in snapshot`);
+    }
+  }
+
+  return changes;
+}
+
+function diffBehavioral(snapshot, liveConfig) {
+  const changes = [];
+  const defaults = liveConfig?.agents?.defaults || {};
+  const snapDefaults = snapshot?.agents?.defaults || {};
+
+  // Check heartbeat still works
+  if (defaults.heartbeat && !defaults.heartbeat.every) {
+    changes.push({
+      category: 'behavioral',
+      severity: 'medium',
+      field: 'agents.defaults.heartbeat.every',
+      change: 'Heartbeat interval missing',
+      autoFixable: true,
+      fix: { type: 'field-add', path: 'agents.defaults.heartbeat.every', value: '15m' }
+    });
+  }
+
+  // Check subagents runTimeoutSeconds still present
+  if (defaults.subagents && !defaults.subagents.runTimeoutSeconds) {
+    changes.push({
+      category: 'behavioral',
+      severity: 'low',
+      field: 'agents.defaults.subagents.runTimeoutSeconds',
+      change: 'runTimeoutSeconds missing from subagents defaults',
+      autoFixable: true,
+      fix: { type: 'field-add', path: 'agents.defaults.subagents.runTimeoutSeconds', value: 900 }
+    });
+  }
+
+  return changes;
+}
+
+function diffSkills() {
+  const changes = [];
+  // Check if skills directory structure is intact
+  const skillsPath = join(
+    process.env.HOME,
+    '.local/share/fnm/node-versions',
+  );
+  // Skills live in node_modules/openclaw/skills — check a known skill exists
+  try {
+    execSync('ls ~/.local/share/fnm/node-versions/*/installation/lib/node_modules/openclaw/skills/coding-agent/SKILL.md 2>/dev/null | head -1', {
+      encoding: 'utf8', shell: '/bin/sh', stdio: ['pipe','pipe','pipe']
+    });
+  } catch {
+    changes.push({
+      category: 'skills',
+      severity: 'medium',
+      field: 'skills.coding-agent',
+      change: 'coding-agent skill not found in expected location',
+      autoFixable: false
+    });
+  }
+  return changes;
+}
+
+// --- Main ---
+async function main() {
+  const openclawVersion = getOpenClawVersion();
+  const aliceVersion = loadJSON(join(ROOT, 'package.json'))?.version || 'unknown';
+
+  console.log(`\n  🔍 A.L.I.C.E. Compatibility Checker`);
+  console.log(`  OpenClaw: ${openclawVersion} | A.L.I.C.E.: ${aliceVersion}\n`);
+
+  const schemaSnapshot = loadJSON(join(ROOT, 'snapshots', 'schema-snapshot.json'));
+  const toolSnapshot = loadJSON(join(ROOT, 'snapshots', 'tool-snapshot.json'));
+  const liveConfig = getOpenClawConfig();
+
+  if (!schemaSnapshot || !toolSnapshot) {
+    warn('Snapshots missing — cannot check compatibility');
+    process.exit(0);
+  }
+
+  if (!liveConfig) {
+    warn('OpenClaw config not found — is OpenClaw installed and configured?');
+    process.exit(1);
+  }
+
+  const breakingChanges = [
+    ...diffConfigSchema(schemaSnapshot, liveConfig),
+    ...diffToolAPI(toolSnapshot, liveConfig),
+    ...diffBehavioral(schemaSnapshot, liveConfig),
+    ...diffSkills()
+  ];
+
+  const criticals = breakingChanges.filter(c => c.severity === 'critical' || c.severity === 'high');
+  const mediums   = breakingChanges.filter(c => c.severity === 'medium');
+  const lows      = breakingChanges.filter(c => c.severity === 'low');
+  const autoFixable = breakingChanges.filter(c => c.autoFixable);
+
+  const report = {
+    generatedAt: new Date().toISOString(),
+    openclawVersion,
+    aliceVersion,
+    snapshotVersion: schemaSnapshot.meta?.openclawVersion,
+    compatible: breakingChanges.length === 0,
+    summary: {
+      total: breakingChanges.length,
+      critical: criticals.length,
+      medium: mediums.length,
+      low: lows.length,
+      autoFixable: autoFixable.length
+    },
+    breakingChanges
+  };
+
+  if (outputFile) {
+    writeFileSync(outputFile, JSON.stringify(report, null, 2));
+    console.log(`  Report written to: ${outputFile}`);
+  }
+
+  if (breakingChanges.length === 0) {
+    console.log('  ✅ Compatible — no breaking changes detected\n');
+    process.exit(0);
+  }
+
+  console.log(`  Found ${breakingChanges.length} issue(s):\n`);
+  for (const c of breakingChanges) {
+    const icon = c.severity === 'high' || c.severity === 'critical' ? '🔴' :
+                 c.severity === 'medium' ? '🟡' : '🟢';
+    const fix = c.autoFixable ? ' [auto-fixable]' : ' [manual review]';
+    console.log(`  ${icon} [${c.category}] ${c.field}`);
+    console.log(`     ${c.change}${fix}\n`);
+  }
+
+  if (autoFixable.length > 0) {
+    console.log(`  💡 ${autoFixable.length} issue(s) can be auto-fixed.`);
+    console.log(`     Run: npx @robbiesrobotics/alice-agents --health\n`);
+  }
+
+  process.exit(criticals.length > 0 ? 1 : 0);
+}
+
+main().catch(err => {
+  console.error('Checker error:', err.message);
+  process.exit(1);
+});