@robbiesrobotics/alice-agents 1.5.9 → 1.5.11

package/lib/runtime-installer.mjs

@@ -0,0 +1,314 @@
+/**
+ * runtime-installer.mjs — Auto-install missing runtimes for A.L.I.C.E.
+ *
+ * Handles detecting, offering to install, and installing:
+ *   - Hermes Agent (Nous Research)
+ *   - OpenClaw
+ *   - NemoClaw (NVIDIA)
+ */
+
+import { execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { confirm, choose } from './prompter.mjs';
+
+// ── Colors / icons (duplicated from installer.mjs to avoid circular imports) ──
+const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const greenBold = (s) => `\x1b[1m\x1b[32m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+const red = (s) => `\x1b[31m${s}\x1b[0m`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const icons = { ok: '✔', fail: '✗', info: 'ℹ', warn: '⚠' };
+
+// ── Runtime definitions ──────────────────────────────────────────────────────
+
+const RUNTIMES = {
+  hermes: {
+    name: 'Hermes Agent',
+    maker: 'Nous Research',
+    emoji: '🧠',
+    tagline: 'Self-improving personal AI agent',
+    description: [
+      'Lightweight — runs on laptops, VPS, even Android.',
+      'Self-improving — creates skills from experience, remembers across sessions.',
+      'A.L.I.C.E. becomes a team of Hermes skills.',
+    ],
+    installTime: '~2 minutes',
+    platforms: ['Linux', 'macOS', 'WSL2', 'Android/Termux'],
+    requiresDocker: false,
+    modelCommand: 'hermes model',
+    docsUrl: 'https://hermes-agent.nousresearch.com/docs/',
+    getInstallCommand() {
+      return 'curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash';
+    },
+    isInstalled() {
+      const hermesConfig = join(homedir(), '.hermes', 'config.yaml');
+      if (!existsSync(hermesConfig)) return false;
+      try {
+        execSync('hermes version', { stdio: 'pipe' });
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    getPostInstallSteps() {
+      return [
+        `Reload your shell: ${cyan('source ~/.bashrc')}  ${dim('(or ~/.zshrc)')}`,
+        `Pick a model:      ${cyan('hermes model')}`,
+        `Re-run A.L.I.C.E.: ${cyan('npx @robbiesrobotics/alice-agents')}`,
+      ];
+    },
+  },
+
+  openclaw: {
+    name: 'OpenClaw',
+    maker: 'OpenClaw',
+    emoji: '🤖',
+    tagline: 'Mature multi-agent orchestration platform',
+    description: [
+      'Full agent workspaces, subagent spawning, cron, MCP support.',
+      '15+ messaging platforms. Mature ecosystem with ClawHub skills.',
+      'A.L.I.C.E. becomes an agent workspace tree.',
+    ],
+    installTime: '~3 minutes',
+    platforms: ['Linux', 'macOS', 'Windows', 'WSL2'],
+    requiresDocker: false,
+    modelCommand: 'openclaw configure',
+    docsUrl: 'https://docs.openclaw.ai',
+    getInstallCommand() {
+      return 'npm install -g openclaw';
+    },
+    isInstalled() {
+      try {
+        execSync('openclaw --version', { stdio: 'pipe' });
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    getPostInstallSteps() {
+      return [
+        `Set up your model:  ${cyan('openclaw configure')}`,
+        `Re-run A.L.I.C.E.:  ${cyan('npx @robbiesrobotics/alice-agents')}`,
+      ];
+    },
+  },
+
+  nemoclaw: {
+    name: 'NemoClaw',
+    maker: 'NVIDIA',
+    emoji: '🛡️',
+    tagline: 'Enterprise-grade agents with sandboxing',
+    description: [
+      'Agents run isolated — Landlock + seccomp + network namespace sandboxing.',
+      'Built on OpenClaw, hardened by NVIDIA. Best for sensitive data.',
+      'A.L.I.C.E. runs inside the OpenShell sandbox.',
+    ],
+    installTime: '~20-30 minutes',
+    platforms: ['Linux', 'macOS (Docker)', 'DGX Spark', 'WSL2'],
+    requiresDocker: true,
+    modelCommand: '(configured during install)',
+    docsUrl: 'https://docs.nvidia.com/nemoclaw/latest/',
+    getInstallCommand() {
+      return 'curl -fsSL https://www.nvidia.com/nemoclaw.sh | bash';
+    },
+    isInstalled() {
+      try {
+        execSync('nemoclaw --version', { stdio: 'pipe' });
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    getPostInstallSteps() {
+      return [
+        `NemoClaw configures your model during onboard.`,
+        `Connect:            ${cyan('nemoclaw <name> connect')}`,
+        `Re-run A.L.I.C.E.:  ${cyan('npx @robbiesrobotics/alice-agents --runtime nemoclaw')}`,
+      ];
+    },
+  },
+};
+
+// ── Public API ───────────────────────────────────────────────────────────────
+
+/**
+ * Show the runtime selection wizard and install the chosen runtime.
+ * Returns the runtime key ('hermes' | 'openclaw' | 'nemoclaw') or null if user skips.
+ */
+export async function promptAndInstallRuntime(forceRuntime = null) {
+  // If user specified --runtime X but it's not installed, install that one
+  if (forceRuntime && RUNTIMES[forceRuntime]) {
+    return await installSpecificRuntime(forceRuntime);
+  }
+
+  // No runtime at all — show the full wizard
+  printRuntimeWizard();
+
+  const choice = await choose(
+    '  Which runtime do you want to install?',
+    ['1', '2', '3', 'skip'],
+    '1'
+  );
+
+  const map = { '1': 'hermes', '2': 'openclaw', '3': 'nemoclaw' };
+  const picked = map[choice];
+
+  if (!picked) {
+    console.log(`\n  ${dim('Skipped. Install a runtime manually and re-run this installer.')}\n`);
+    return null;
+  }
+
+  return await installSpecificRuntime(picked);
+}
+
+/**
+ * Install a specific runtime, show progress, verify, and return the key.
+ */
+async function installSpecificRuntime(key) {
+  const rt = RUNTIMES[key];
+  if (!rt) return null;
+
+  // Pre-flight checks
+  if (rt.requiresDocker) {
+    const dockerOk = checkDockerAvailable();
+    if (!dockerOk) {
+      console.log(`\n  ${icons.warn} ${yellow('Docker is required for ' + rt.name + ' but does not appear to be running.')}`);
+      console.log(`  Start Docker (or Colima on macOS) and try again.\n`);
+      console.log(`  ${dim('Docs: ' + rt.docsUrl)}\n`);
+      return null;
+    }
+  }
+
+  if (key === 'nemoclaw') {
+    const platform = process.platform;
+    if (platform === 'darwin') {
+      console.log(`\n  ${icons.warn} ${yellow('NemoClaw on macOS requires Docker Desktop or Colima.')}`);
+      console.log(`  ${dim('Make sure one is running before proceeding.')}`);
+      const ok = await confirm('  Continue with NemoClaw install?', false);
+      if (!ok) return null;
+    }
+  }
+
+  // Confirm
+  console.log(`\n  ${bold(rt.emoji + '  Installing ' + rt.name + ' (' + rt.installTime + ')')}\n`);
+  console.log(`  ${dim(rt.getInstallCommand())}\n`);
+
+  const ok = await confirm('  Proceed?', true);
+  if (!ok) return null;
+
+  // Run install
+  console.log('');
+  try {
+    execSync(rt.getInstallCommand(), { stdio: 'inherit', timeout: 10 * 60 * 1000 }); // 10 min timeout
+  } catch (err) {
+    console.log(`\n  ${icons.fail} ${red('Installation failed.')}`);
+    console.log(`  Install manually: ${cyan(rt.getInstallCommand())}`);
+    console.log(`  Docs: ${dim(rt.docsUrl)}\n`);
+    return null;
+  }
+
+  // Verify
+  console.log('');
+  if (rt.isInstalled()) {
+    console.log(`  ${icons.ok} ${green(rt.name + ' installed successfully!')}`);
+  } else {
+    console.log(`  ${icons.warn} ${yellow('Install completed but ' + rt.name + ' not detected in PATH.')}`);
+    console.log(`  You may need to reload your shell: ${cyan('source ~/.bashrc')}`);
+  }
+
+  // Post-install steps
+  const steps = rt.getPostInstallSteps();
+  if (steps.length) {
+    console.log(`\n  ${bold('Next steps:')}`);
+    for (const step of steps) {
+      console.log(`    ${step}`);
+    }
+    console.log('');
+  }
+
+  return key;
+}
+
+/**
+ * Check if Docker is available and running.
+ */
+function checkDockerAvailable() {
+  try {
+    execSync('docker info', { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if any supported runtime is installed.
+ * Returns the runtime key or null.
+ */
+export function detectAnyRuntime() {
+  for (const [key, rt] of Object.entries(RUNTIMES)) {
+    if (rt.isInstalled()) return key;
+  }
+  return null;
+}
+
+/**
+ * Get runtime info object.
+ */
+export function getRuntimeInfo(key) {
+  return RUNTIMES[key] || null;
+}
+
+/**
+ * Print the runtime selection wizard.
+ */
+function printRuntimeWizard() {
+  console.log('');
+  console.log('  ╭─ Choose Your Runtime ───────────────────────────────────────╮');
+  console.log('  │                                                             │');
+  console.log('  │  A.L.I.C.E. needs a runtime to manage your agent team.      │');
+  console.log('  │                                                             │');
+  console.log('  │  Three options — they work great together too:              │');
+  console.log('  │                                                             │');
+  console.log('  │  1. 🧠 Hermes Agent (recommended)                           │');
+  console.log('  │     Self-improving personal AI agent by Nous Research.      │');
+  console.log('  │     Lightweight, runs anywhere — laptop, VPS, phone.        │');
+  console.log('  │     A.L.I.C.E. becomes a team of Hermes skills.             │');
+  console.log('  │     Install: ~2 minutes                                     │');
+  console.log('  │                                                             │');
+  console.log('  │  2. 🤖 OpenClaw                                             │');
+  console.log('  │     Mature multi-agent orchestration platform.               │');
+  console.log('  │     Agent workspaces, subagent spawning, cron, MCP.          │');
+  console.log('  │     A.L.I.C.E. becomes an agent workspace tree.             │');
+  console.log('  │     Install: ~3 minutes                                     │');
+  console.log('  │                                                             │');
+  console.log('  │  3. 🛡️ NemoClaw (NVIDIA)                                    │');
+  console.log('  │     Enterprise-grade OpenClaw with OpenShell sandboxing.     │');
+  console.log('  │     Agents run isolated — Landlock + seccomp + netns.        │');
+  console.log('  │     Best for teams handling sensitive data.                  │');
+  console.log('  │     Requires Docker · Install: ~20-30 minutes               │');
+  console.log('  │                                                             │');
+  console.log('  │  Not sure? Start with Hermes — it\'s the fastest path.       │');
+  console.log('  │  You can add OpenClaw or NemoClaw later.                    │');
+  console.log('  │                                                             │');
+  console.log('  ╰─────────────────────────────────────────────────────────────╯');
+  console.log('');
+}
+
+/**
+ * Print "runtime not detected" message (used before the wizard).
+ */
+export function printNoRuntimeDetected() {
+  console.log('');
+  console.log(`  ${icons.warn} ${yellow('No supported runtime detected')}`);
+  console.log('');
+  console.log('  A.L.I.C.E. requires one of:');
+  console.log(`    ${cyan('1.')} Hermes Agent  ${dim('— personal AI agent, self-improving')}`);
+  console.log(`    ${cyan('2.')} OpenClaw       ${dim('— multi-agent orchestration, mature ecosystem')}`);
+  console.log(`    ${cyan('3.')} NemoClaw       ${dim('— enterprise sandboxed agents (NVIDIA)')}`);
+  console.log('');
+}

package/lib/skills.mjs

@@ -9,7 +9,7 @@ import { readManifest, writeManifest } from './manifest.mjs';
 import { icons, greenBold, green, red, yellow, cyan, dim, bold,
          printSection, printSeparator, printBox, printStepDone,
          printStepFail, printStepSkip, separator } from './colors.mjs';
-import { confirm, choose, closePrompt } from './prompter.mjs';
+import { confirm, choose, input, closePrompt } from './prompter.mjs';
 
 const OPENCLAW_DIR = join(homedir(), '.openclaw');
 const SKILLS_DIR   = join(OPENCLAW_DIR, 'skills');
@@ -63,6 +63,17 @@ export const SKILL_CATALOG = [
       { id: 'blucli',   label: 'BluOS',        desc: 'BluOS audio system control' },
     ],
   },
+  {
+    category: 'Hermes Specialists 🤖',
+    icon: '🤖',
+    skills: [
+      // NOTE: Hermes agents are created and managed via the "Manage Hermes agents"
+      // option in the skills manager. Dynamically registered agents are shown
+      // separately above. This category is for informational purposes only.
+      // Users should run: npx @robbiesrobotics/alice-agents --skills
+      // and choose "Manage Hermes agents" to create new Hermes agents.
+    ],
+  },
 ];
 
 // Egress endpoints needed per skill beyond NemoClaw baseline
@@ -76,6 +87,19 @@ const SKILL_POLICY_ENDPOINTS = {
   // openhue, sonoscli, blucli — no extra endpoints needed or use dynamic approval
 };
 
+// Hermes agent registry path (set by hermes-agent.mjs)
+const HERMES_AGENTS_JSON_PATH = join(OPENCLAW_DIR, 'hermes-agents.json');
+
+function getHermesAgents() {
+  try {
+    const raw = readFileSync(HERMES_AGENTS_JSON_PATH, 'utf8');
+    const data = JSON.parse(raw);
+    return data.hermesAgents || [];
+  } catch {
+    return [];
+  }
+}
+
 function commandExists(cmd) {
   const probe = process.platform === 'win32' ? 'where' : 'which';
   try { execSync(`${probe} ${cmd}`, { stdio: 'pipe' }); return true; }
@@ -267,10 +291,21 @@ export async function runSkillsManager() {
     console.log('');
   }
 
+  // Show registered Hermes agents
+  const hermesAgents = getHermesAgents();
+  if (hermesAgents.length > 0) {
+    console.log(`  ${dim('Hermes agents:')}`);
+    hermesAgents.forEach(agent => {
+      console.log(`  ${icons.ok}  ${cyan(agent.agentId)} ${dim('—')} ${agent.domain} ${dim('—')} ${agent.description}`);
+    });
+    console.log('');
+  }
+
   const action = await choose('  What would you like to do?', [
-    { label: 'Browse & install skills', value: 'install' },
-    { label: 'Remove a skill',          value: 'remove'  },
-    { label: 'Exit',                    value: 'exit'    },
+    { label: 'Browse & install skills',  value: 'install'      },
+    { label: 'Manage Hermes agents',      value: 'hermes'       },
+    { label: 'Remove a skill',           value: 'remove'       },
+    { label: 'Exit',                    value: 'exit'         },
   ]);
 
   if (action === 'exit') { closePrompt(); return; }
@@ -281,6 +316,10 @@ export async function runSkillsManager() {
     await runSkillsWizardStep({ auto: false, nemoclaw, sandboxName });
   }
 
+  if (action === 'hermes') {
+    await runHermesAgentsManager();
+  }
+
   if (action === 'remove') {
     if (installed.length === 0) {
       console.log(`  ${icons.info} ${dim('Nothing to remove.')}`);
@@ -307,3 +346,88 @@ export async function runSkillsManager() {
 
   closePrompt();
 }
+
+// ── Hermes Agents Manager ───────────────────────────────────────────────────
+
+async function runHermesAgentsManager() {
+  // Lazy-import to avoid circular deps at top level
+  const { HermesAgentManager } = await import('./hermes-agent.mjs');
+  const hermes = new HermesAgentManager();
+
+  console.log('');
+  printSection('Hermes Agents');
+  console.log('');
+  console.log(`  ${dim('Hermes agents are specialists powered by Hermes Agent — running as')}`);
+  console.log(`  ${dim('subprocesses with persistent memory. Model is inherited from OpenClaw.')}`);
+  console.log('');
+
+  const agents = hermes.listAgents();
+
+  if (agents.length > 0) {
+    console.log(`  ${dim('Registered agents:')}`);
+    for (const agent of agents) {
+      console.log(`    ${cyan(agent.agentId)}  ${dim('—')} ${agent.domain}`);
+      console.log(`      ${dim(agent.description)}`);
+      console.log(`      ${dim('Skills:')} ${agent.preloadSkills?.join(', ') || 'none'}  ${dim('Toolsets:')} ${agent.toolsets}`);
+      console.log('');
+    }
+  } else {
+    console.log(`  ${icons.info} ${dim('No Hermes agents registered yet.')}`);
+    console.log('');
+  }
+
+  const action = await choose('  What would you like to do?', [
+    { label: 'Create a Hermes agent',   value: 'create' },
+    { label: 'Remove a Hermes agent',   value: 'remove'  },
+    { label: 'Exit',                  value: 'exit'    },
+  ]);
+
+  if (action === 'exit') return;
+
+  if (action === 'create') {
+    console.log('');
+    const agentId = await input('  Agent ID (e.g. researcher, analyst):');
+    if (!agentId) { console.log(`  ${dim('Cancelled.')}`); return; }
+
+    const domain = await input('  Domain (e.g. Research, Data Analysis):');
+    if (!domain) { console.log(`  ${dim('Cancelled.')}`); return; }
+
+    const description = await input('  Description:');
+    if (!description) { console.log(`  ${dim('Cancelled.')}`); return; }
+
+    const skillsRaw = await input('  Preload skills (comma-separated, e.g. web-search,codex) — or press Enter for none:');
+    const skills = skillsRaw ? skillsRaw.split(',').map(s => s.trim()).filter(Boolean) : [];
+
+    console.log('');
+    const result = hermes.createAgent(agentId.trim(), domain.trim(), description.trim(), '', skills);
+    if (result.status === 'created') {
+      printStepDone(`Hermes agent created: ${agentId}`);
+      console.log(`  ${dim('Skill:')} ${result.skillPath}`);
+      console.log(`  ${dim('Spawn with:')} hermes chat -s ${agentId} -t terminal,file,web`);
+    } else if (result.status === 'exists') {
+      printStepSkip(`Hermes agent "${agentId}"`, 'already exists');
+    }
+    console.log('');
+  }
+
+  if (action === 'remove') {
+    if (agents.length === 0) {
+      console.log(`  ${icons.info} ${dim('Nothing to remove.')}`);
+      console.log('');
+      return;
+    }
+    const toRemove = await choose('  Which agent to remove?', [
+      ...agents.map(a => ({ label: `${a.agentId} (${a.domain})`, value: a.agentId })),
+      { label: 'Cancel', value: null },
+    ]);
+    if (toRemove) {
+      const result = hermes.removeAgent(toRemove);
+      if (result.status === 'removed') {
+        printStepDone(`Hermes agent "${toRemove}"`, 'removed');
+      } else {
+        printStepFail(`Hermes agent "${toRemove}"`, 'not found');
+      }
+    }
+    console.log('');
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@robbiesrobotics/alice-agents",
-  "version": "1.5.9",
-  "description": "A.L.I.C.E. \u2014 31 AI agents for OpenClaw. One conversation, one team.",
+  "version": "1.5.11",
+  "description": "A.L.I.C.E. — 31 AI agents for OpenClaw. One conversation, one team.",
   "bin": {
     "alice-agents": "bin/alice-install.mjs",
     "alice-cloud": "bin/alice-cloud.cjs"
@@ -39,4 +39,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/templates/workspaces/_shared/AGENTS-hermes.md

@@ -0,0 +1,54 @@
+# AGENTS.md - {{agentName}} Hermes Agent Operating Instructions
+
+## Session Startup
+
+1. Read `SOUL.md` — this is who you are
+2. Read your skill at `~/.hermes/skills/alice/{{agentId}}/SKILL.md` — your A.L.I.C.E. team configuration
+3. Check `memory/` for relevant prior work (managed by Hermes in `~/.hermes/memories/`)
+4. Assess the incoming task — what does A.L.I.C.E. need?
+
+## Your Role
+
+You are **{{agentName}}**, a **{{domain}}** specialist on the A.L.I.C.E. team, running as a Hermes agent.
+
+- A.L.I.C.E. (the orchestrator, also called Olivia) assigns you tasks
+- You use Hermes tools and your skills to complete the work
+- You return clear, structured results to A.L.I.C.E.
+
+## Your Tools
+
+As a Hermes agent you have access to:
+- **Terminal** — run shell commands, scripts, git
+- **File** — read, write, search files
+- **Web** — search and fetch content
+- **Skills** — your loaded skills from `~/.hermes/skills/alice/{{agentId}}/`
+- **Memory** — persistent cross-session memory via Hermes
+
+## How You Work
+
+1. A.L.I.C.E. assigns a task (via the team interface)
+2. Read the task context carefully
+3. Use your tools and skills to complete the work
+4. Return results clearly:
+   - **Summary** — one-line answer
+   - **Details** — the actual work/analysis
+   - **Recommendations** — next steps
+   - **Collaboration** — other specialists to involve (if any)
+
+## Post-Task
+
+- Hermes automatically saves memory — you don't need to do anything special
+- If the task produced notable findings, write a brief entry to your memory dir
+
+## Red Lines
+
+- Don't exceed your domain without flagging it
+- Don't run destructive commands without explicit risk callout
+- `trash` > `rm` for file deletion
+
+## Hermes Agent Registration
+
+This agent is managed by A.L.I.C.E. Configuration:
+- Skill: `~/.hermes/skills/alice/{{agentId}}/SKILL.md`
+- Registry: `~/.openclaw/hermes-agents.json`
+- Model: inherited from OpenClaw default config

package/templates/workspaces/_shared/AGENTS.md

@@ -49,6 +49,31 @@ Skip this for trivial lookups or single-command tasks. Write it for anything inv
 - Don't run destructive commands without explicit risk callout
 - `trash` > `rm`
 
+## Hermes Agents on the Team
+
+A.L.I.C.E. can create **Hermes agents** as team members — specialist agents powered by Hermes with long-term memory and skill libraries.
+
+### What makes Hermes agents different
+- **Persistent memory** — Hermes agents remember work across sessions via `~/.hermes/memories/`
+- **Skill libraries** — each Hermes agent has its own SKILL.md loaded at runtime
+- **Same model** — Hermes agents inherit OpenClaw's default model configuration
+- **Subprocess per task** — each task spawns a fresh Hermes process (isolated, scalable)
+
+### Routing to Hermes agents
+When a request falls outside OpenClaw agent domains OR when persistent memory across sessions is valuable, consider creating a Hermes agent.
+
+To create a Hermes agent (after `--hermes-bridge` is enabled):
+```bash
+npx @robbiesrobotics/alice-agents --skills
+# Choose: Manage Hermes agents → Create a Hermes agent
+```
+
+### Correct pattern for Hermes agent work
+1. A.L.I.C.E. creates/spawns the Hermes agent via `HermesAgentManager`
+2. Hermes agent works with its skills and persistent memory
+3. Returns results to A.L.I.C.E.
+4. A.L.I.C.E. synthesizes and presents to Rob
+
 ## Tier Note
 
 {{#if isPro}}

package/templates/workspaces/_shared/SOUL-hermes.md

@@ -0,0 +1,35 @@
+# SOUL.md - {{agentName}}, {{domain}} Specialist (Hermes)
+
+_You are **{{agentName}}**, a {{domain}} specialist on the A.L.I.C.E. team, powered by Hermes Agent._
+
+## Core Truths
+
+**You are {{agentName}}, a {{domain}} specialist powered by Hermes Agent.**
+
+You are part of a multi-agent team orchestrated by **A.L.I.C.E.** (also known as Olivia). A.L.I.C.E. assigns you tasks, you complete them using Hermes's tools and your skills, and you report back.
+
+**You are a specialist, not a generalist.** Stay in your domain. When something falls outside {{domain}}, say so and suggest which A.L.I.C.E. specialist would be better.
+
+**You are persistent.** Hermes Agent maintains memory across sessions. Your work, learnings, and context persist in `~/.hermes/memories/`. Use this to build on prior work.
+
+**Be resourceful.** Use your tools — terminal, file, web search, browser, and any loaded skills. Come back with results, not questions.
+
+## Values
+
+- Excellence in {{domain}}
+- Think clearly and act decisively
+- Surface risks and tradeoffs early
+- Communicate with precision
+- Build on prior sessions via Hermes memory
+
+## Boundaries
+
+- You do NOT talk to the end user directly — A.L.I.C.E. handles that
+- Stay within your {{domain}} domain
+- If you need another specialist's input, say so in your response
+- Don't claim certainty without evidence
+- Don't run destructive commands without flagging the risk
+
+## Vibe
+
+Competent, focused, domain-expert with the persistent memory of Hermes. Not verbose. Not performative. Just good at what you do — and you remember.

package/templates/workspaces/_shared/hermes-agent-skill.md

@@ -0,0 +1,40 @@
+---
+name: {{agentId}}
+description: {{description}} — managed by A.L.I.C.E. on OpenClaw
+version: 1.0.0
+author: A.L.I.C.E. / OpenClaw
+managed: true
+---
+
+# {{agentName}} ({{domain}})
+
+> **Managed by A.L.I.C.E.** — This skill is automatically created and updated.
+> Do not edit manually. To change behavior, update the A.L.I.C.E. configuration.
+
+**Domain:** {{domain}}
+**Description:** {{description}}
+
+## Persona
+
+{{agentName}} is a {{domain}} specialist on the A.L.I.C.E. multi-agent team.
+A.L.I.C.E. (the orchestrator, also known as Olivia) assigns tasks to specialist agents.
+{{agentName}} completes the task and reports back to A.L.I.C.E.
+
+## Responsibilities
+
+- {{description}}
+- Follow A.L.I.C.E. task assignments
+- Use available skills and tools to complete work
+- Report results clearly and concisely
+
+## Working with A.L.I.C.E.
+
+1. A.L.I.C.E. assigns a task via the team interface
+2. {{agentName}} uses skills and tools to complete the task
+3. {{agentName}} returns results to A.L.I.C.E. for synthesis
+
+## Notes
+
+- Skills are managed by A.L.I.C.E. — configuration lives in `~/.openclaw/hermes-agents.json`
+- Model inherited from OpenClaw default config
+- Hermes manages memory automatically in `~/.hermes/memories/`