@robbiesrobotics/alice-agents 1.5.10 → 1.5.13

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/workspace-scaffolder.mjs

@@ -3,6 +3,11 @@ import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { buildCodingAgentSkillContent, resolveCodingAgentPreference } from './coding-agent.mjs';
+import {
+  ALICE_RUNTIME_HOME,
+  getAliceRuntimeWorkspaceDir,
+  writeAliceRuntimeDefinition,
+} from './alice-runtime-adapter.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const TEMPLATES_DIR = join(__dirname, '..', 'templates', 'workspaces');
@@ -13,7 +18,7 @@ const SKILLS_DIR = join(OPENCLAW_DIR, 'skills');
 const PRODUCT_FILES = ['SOUL.md', 'AGENTS.md', 'IDENTITY.md', 'TOOLS.md'];
 
 // User files — only created if missing
-const USER_FILES = ['PLAYBOOK.md', 'LEARNINGS.md', 'FEEDBACK.md', 'USER.md', 'MEMORY.md'];
+const USER_FILES = ['PLAYBOOK.md', 'LEARNINGS.md', 'FEEDBACK.md', 'USER.md', 'MEMORY.md', 'HEARTBEAT.md'];
 
 function renderTemplate(template, vars) {
   let result = template;
@@ -31,12 +36,17 @@ function loadTemplate(filename) {
   return null;
 }
 
-function getTemplateVariant(baseName, agent) {
-  // Check for agent-specific override first
-  const agentOverridePath = join(TEMPLATES_DIR, agent.id, baseName);
-  if (existsSync(agentOverridePath)) {
-    return readFileSync(agentOverridePath, 'utf8');
+function loadAgentTemplate(agent, filename) {
+  const agentPath = join(TEMPLATES_DIR, agent.id, filename);
+  if (existsSync(agentPath)) {
+    return readFileSync(agentPath, 'utf8');
   }
+  return null;
+}
+
+function getTemplateVariant(baseName, agent) {
+  const agentTemplate = loadAgentTemplate(agent, baseName);
+  if (agentTemplate) return agentTemplate;
 
   // Use variant-based naming
   if (agent.isOrchestrator) {
@@ -53,8 +63,170 @@ function getTemplateVariant(baseName, agent) {
   return loadTemplate(baseName);
 }
 
-export function scaffoldWorkspace(agent, userInfo, agentCount) {
-  const workspaceDir = join(OPENCLAW_DIR, `workspace-${agent.id}`);
+function getUserFileTemplate(filename, agent) {
+  return loadTemplate(filename);
+}
+
+function normalizeSoulContent(content, agent) {
+  if (agent.isOrchestrator) {
+    return content
+      .replace(
+        /\*\*You are A\.L\.I\.C\.E\., orchestrator of a \d+-agent team\.\*\*/,
+        '**You are A.L.I.C.E., orchestrator of the A.L.I.C.E. team.**'
+      )
+      .replace(
+        /\*\*Memory recall before answering\.\*\*[\s\S]*?Match scores in the 0\.5\+ range are usually directly relevant; under 0\.3 is noise\./m,
+        `**Memory recall before answering.** When a question touches past decisions, projects, people, or technical details, check the team's stored context first.
+
+Start with the most relevant local sources: \`MEMORY.md\`, recent \`LEARNINGS.md\` entries, and files under the owning agent's \`memory/\` directory.
+
+If \`mempalace\` is installed on this machine, you may also run \`mempalace search "<query>"\` via the \`exec\` tool for faster recall, using \`--wing <agentId>\` when one agent clearly owns the topic. Treat \`mempalace\` as optional tooling, not a guaranteed dependency of every install.`
+      );
+  }
+
+  if (!content.includes('mempalace search "<query>" --wing')) {
+    return content;
+  }
+
+  return content.replace(
+    /## Memory[\s\S]*?Do NOT journal:/m,
+    `## Memory
+
+You have a persistent workspace memory. Keep \`MEMORY.md\`, recent \`LEARNINGS.md\` entries, and the \`memory/\` directory useful and current.
+
+**Recall before answering.** When a question touches your past work, decisions, or technical history:
+
+1. Check your local workspace context first: \`MEMORY.md\`, recent \`LEARNINGS.md\` entries, and relevant files under \`memory/\`.
+2. If \`mempalace\` is installed on this machine, you may also run \`mempalace search "<query>" --wing ${agent.id}\` via \`exec\` for faster recall.
+3. Treat \`mempalace\` as optional tooling, not a guaranteed dependency of every A.L.I.C.E. install.
+
+**Write durable learnings.** When you learn something worth remembering across sessions, append it to \`LEARNINGS.md\` or add a dated file under \`memory/\`. If \`mempalace\` is installed later, those notes can be indexed then.
+
+Do NOT journal:`
+  );
+}
+
+function normalizeAgentsContent(content, agent) {
+  if (!agent.isOrchestrator) {
+    return content;
+  }
+
+  return content
+    .replace(
+      /You are \*\*A\.L\.I\.C\.E\.\*\*, the \*\*orchestrator\*\* of the A\.L\.I\.C\.E\. team\. You coordinate \d+ specialist agents to deliver results for Rob\./,
+      'You are **A.L.I.C.E.**, the **orchestrator** of the A.L.I.C.E. team. You coordinate the specialist team to deliver results for Rob.'
+    )
+    .replace(
+      /2\. \*\*Memory recall\*\* — .*?\n3\./s,
+      '2. **Memory recall** — when a request touches past decisions, projects, people, or technical history, check the most relevant local context first: the owning agent\'s `MEMORY.md`, recent `LEARNINGS.md` entries, and files under `memory/`. If `mempalace` is installed on this machine, you may also search it via `exec`, using `--wing <agentId>` when one specialist clearly owns the topic.\n3.'
+    );
+}
+
+function normalizeCodingToolContent(filename, content) {
+  if (!['SOUL.md', 'AGENTS.md', 'TOOLS.md', 'PLAYBOOK.md'].includes(filename)) {
+    return content;
+  }
+
+  return content
+    .replaceAll('`claude_code`', '`coding-agent`')
+    .replaceAll('claude_code "', 'coding-agent "')
+    .replaceAll(
+      '**For coding tasks, use the `coding-agent` skill** — it runs Claude Code CLI autonomously with full file editing, terminal, and search capabilities',
+      '**For coding tasks, use the `coding-agent` skill** — it selects the preferred coding CLI for this machine, preferring Codex for OpenAI defaults and Claude Code for Anthropic defaults'
+    )
+    .replaceAll(
+      'Use `coding-agent` for: writing code, debugging, refactoring, multi-file changes, test creation',
+      'Use `coding-agent` for: writing code, debugging, refactoring, multi-file changes, and test creation'
+    )
+    .replaceAll('## Primary Tool: Claude Code', '## Primary Tool: coding-agent')
+    .replaceAll(
+      '**For any non-trivial coding task, use the `coding-agent` skill.** It delegates to the Claude Code CLI, which has its own file editing, terminal, and search capabilities. This is your power tool.',
+      '**For any non-trivial coding task, use the `coding-agent` skill.** It chooses the preferred coding CLI for this machine, preferring Codex for OpenAI defaults and Claude Code for Anthropic defaults. This is your power tool.'
+    )
+    .replaceAll(
+      '- **Always set workdir** to the project root so Claude Code can navigate the full codebase',
+      '- **Always set workdir** to the project root so the coding CLI can navigate the full codebase'
+    )
+    .replaceAll(
+      "- Review Claude Code's output before incorporating into your response",
+      "- Review the coding agent's output before incorporating it into your response"
+    )
+    .replaceAll(
+      "- Review Claude Code's output before incorporating it into your response",
+      "- Review the coding agent's output before incorporating it into your response"
+    )
+    .replaceAll(
+      '- `read/write/edit` — simple file reads/edits when Claude Code is overkill',
+      '- `read/write/edit` — simple file reads/edits when the coding agent is overkill'
+    )
+    .replaceAll(
+      '- **coding-agent** — Full Claude Code CLI for coding tasks',
+      '- **coding-agent** — Provider-aware coding CLI skill for coding tasks'
+    )
+    .replaceAll(
+      '- Use `coding-agent` for multi-file changes and complex coding tasks',
+      '- Use `coding-agent` for multi-file changes and complex coding tasks'
+    )
+    .replaceAll(
+      '**For multi-file tasks, use Claude Code.** Don\'t hand-edit patches file by file when the coding agent can navigate the full codebase faster and more reliably. Delegate implementation; own the plan and verification.',
+      '**For multi-file tasks, use the `coding-agent` skill.** It can pick the best available coding CLI for this machine and navigate the full codebase faster than manual patch-by-patch edits. Delegate implementation; own the plan and verification.'
+    )
+    .replaceAll(
+      'Before spawning Claude Code directly or writing implementation code yourself:',
+      'Before spawning the `coding-agent` skill directly or writing implementation code yourself:'
+    )
+    .replaceAll(
+      '3. Only fall back to direct Claude Code if genuinely no specialist covers it',
+      '3. Only fall back to direct `coding-agent` use if genuinely no specialist covers it'
+    )
+    .replaceAll(
+      "3. Felix implements using Claude Code with Nadia's spec as the brief",
+      "3. Sasha implements using the `coding-agent` skill with Nadia's spec as the brief"
+    )
+    .replaceAll(
+      '**Wrong:** A.L.I.C.E. spawns Claude Code directly for UI without involving Nadia or Felix',
+      '**Wrong:** A.L.I.C.E. spawns the `coding-agent` skill directly for UI without involving Nadia or Sasha'
+    )
+    .replaceAll(
+      '**Right:** Nadia → Felix → Claude Code → Quinn → A.L.I.C.E.',
+      '**Right:** Nadia → Sasha → coding-agent → Morgan → A.L.I.C.E.'
+    )
+    .replaceAll(
+      '- **Backend/API** → Dylan → Claude Code → Quinn (tests)',
+      '- **Backend/API** → Dylan → coding-agent → Morgan (tests)'
+    )
+    .replaceAll(
+      "- Don't spawn Claude Code directly for design work — route through Nadia first",
+      "- Don't spawn the `coding-agent` skill directly for design work — route through Nadia first"
+    )
+    .replaceAll(
+      "- Don't iterate on UI without a design spec. Nadia → Felix → Claude Code is the correct chain.",
+      "- Don't iterate on UI without a design spec. Nadia → Sasha → coding-agent is the correct chain."
+    )
+    .replaceAll(
+      "3. **Felix** — frontend implementation (spawns Claude Code with Nadia's spec)",
+      "3. **Sasha** — frontend implementation (spawns the `coding-agent` skill with Nadia's spec)"
+    );
+}
+
+function normalizeTemplateContent(filename, content, agent) {
+  if (filename === 'SOUL.md') {
+    return normalizeCodingToolContent(filename, normalizeSoulContent(content, agent));
+  }
+  if (filename === 'AGENTS.md') {
+    return normalizeCodingToolContent(filename, normalizeAgentsContent(content, agent));
+  }
+  return normalizeCodingToolContent(filename, content);
+}
+
+function resolveWorkspaceDir(agent, runtime) {
+  if (runtime === 'alice-runtime') return getAliceRuntimeWorkspaceDir(agent.id);
+  return join(OPENCLAW_DIR, `workspace-${agent.id}`);
+}
+
+export function scaffoldWorkspace(agent, userInfo, agentCount, options = {}) {
+  const runtime = options.runtime || 'openclaw';
+  const workspaceDir = resolveWorkspaceDir(agent, runtime);
 
   // Create workspace + memory dirs
   mkdirSync(join(workspaceDir, 'memory'), { recursive: true });
@@ -64,6 +236,7 @@ export function scaffoldWorkspace(agent, userInfo, agentCount) {
     userTimezone: userInfo.timezone,
     userNotes: userInfo.notes ? `- **Notes:** ${userInfo.notes}` : '',
     agentName: agent.name,
+    agentId: agent.id,
     agentDomain: agent.domain,
     agentEmoji: agent.emoji,
     agentDescription: agent.description,
@@ -77,7 +250,7 @@ export function scaffoldWorkspace(agent, userInfo, agentCount) {
   for (const filename of PRODUCT_FILES) {
     const template = getTemplateVariant(filename, agent);
     if (template) {
-      const content = renderTemplate(template, vars);
+      const content = normalizeTemplateContent(filename, renderTemplate(template, vars), agent);
       writeFileSync(join(workspaceDir, filename), content, 'utf8');
       written.push(filename);
     }
@@ -87,9 +260,9 @@ export function scaffoldWorkspace(agent, userInfo, agentCount) {
   for (const filename of USER_FILES) {
     const filePath = join(workspaceDir, filename);
     if (!existsSync(filePath)) {
-      const template = loadTemplate(filename);
+      const template = getUserFileTemplate(filename, agent);
       if (template) {
-        const content = renderTemplate(template, vars);
+        const content = normalizeTemplateContent(filename, renderTemplate(template, vars), agent);
         writeFileSync(filePath, content, 'utf8');
         written.push(filename);
       }
@@ -98,12 +271,15 @@ export function scaffoldWorkspace(agent, userInfo, agentCount) {
     }
   }
 
-  return { workspaceDir, written, skipped };
+  const definitionPath = runtime === 'alice-runtime' ? writeAliceRuntimeDefinition(agent) : null;
+
+  return { workspaceDir, written, skipped, definitionPath };
 }
 
-export function scaffoldSkills(preference = null) {
+export function scaffoldSkills(preference = null, options = {}) {
   const codingAgentPreference = preference || resolveCodingAgentPreference();
-  const codingAgentSkillDir = join(SKILLS_DIR, codingAgentPreference.skillId);
+  const skillsDir = options.runtime === 'alice-runtime' ? join(ALICE_RUNTIME_HOME, 'skills') : SKILLS_DIR;
+  const codingAgentSkillDir = join(skillsDir, codingAgentPreference.skillId);
   mkdirSync(codingAgentSkillDir, { recursive: true });
 
   const skillDestPath = join(codingAgentSkillDir, 'SKILL.md');
@@ -111,17 +287,17 @@ export function scaffoldSkills(preference = null) {
   return codingAgentPreference;
 }
 
-export function scaffoldAll(agents, userInfo, skillPreference = null) {
+export function scaffoldAll(agents, userInfo, skillPreference = null, options = {}) {
   const agentCount = agents.length;
   const results = [];
 
   for (const agent of agents) {
-    const result = scaffoldWorkspace(agent, userInfo, agentCount);
+    const result = scaffoldWorkspace(agent, userInfo, agentCount, options);
     results.push({ agent: agent.id, ...result });
   }
 
   // Install skills
-  const installedSkill = scaffoldSkills(skillPreference);
+  const installedSkill = scaffoldSkills(skillPreference, options);
 
   return { workspaces: results, installedSkill };
 }

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@robbiesrobotics/alice-agents",
-  "version": "1.5.10",
-  "description": "A.L.I.C.E. — 31 AI agents for OpenClaw. One conversation, one team.",
+  "version": "1.5.13",
+  "description": "A.L.I.C.E. — 36 AI agents for Alice Runtime, OpenClaw, NemoClaw, and Hermes Agent. One conversation, one team.",
   "bin": {
-    "alice-agents": "bin/alice-install.mjs",
-    "alice-cloud": "bin/alice-cloud.cjs"
+    "alice-agents": "bin/alice-install.mjs"
   },
   "type": "module",
   "engines": {
@@ -21,13 +20,19 @@
   "files": [
     "bin/",
     "lib/",
-    "tools/",
-    "snapshots/",
+    "tools/*.mjs",
+    "snapshots/*.json",
     "templates/agents-starter.json",
     "templates/agents-pro.json",
-    "templates/mission-control-bridge/",
-    "templates/skills/",
-    "templates/workspaces/",
+    "templates/workspaces/_shared/*.md",
+    "templates/workspaces/athena/*.md",
+    "templates/workspaces/devon/*.md",
+    "templates/workspaces/dylan/*.md",
+    "templates/workspaces/felix/*.md",
+    "templates/workspaces/morgan/*.md",
+    "templates/workspaces/priya/*.md",
+    "templates/workspaces/quinn/*.md",
+    "templates/workspaces/sasha/*.md",
     "README.md"
   ],
   "scripts": {