serpentstack 0.2.3 → 0.2.5

package/bin/serpentstack.js

@@ -2,7 +2,7 @@
 
 import { error, bold, dim, green, cyan, getVersion, printHeader } from '../lib/utils/ui.js';
 
-function parseFlags(args) {
+function parseArgs(args) {
   const flags = {};
   const positional = [];
   for (const arg of args) {
@@ -20,15 +20,16 @@ function showHelp() {
   printHeader();
   console.log(`  ${bold('Usage:')} serpentstack <command> [options]
 
-  ${bold(green('Stack commands'))} ${dim('(new projects)')}
-    ${cyan('stack new')} <name>              Scaffold a new project from the template
+  ${bold(green('New projects'))}
+    ${cyan('stack new')} <name>              Scaffold a full project from the template
     ${cyan('stack update')}                  Update template-level files to latest
 
-  ${bold(green('Skills commands'))} ${dim('(any project)')}
-    ${cyan('skills init')}                   Download base skills + persistent agent configs
+  ${bold(green('Any project'))}
+    ${cyan('skills')}                        Download base skills + persistent agent configs
     ${cyan('skills update')}                 Update base skills to latest versions
-    ${cyan('skills persistent')}             Guided setup: configure + install + start agent
-    ${cyan('skills persistent')} --stop      Stop the background agent
+    ${cyan('persistent')}                    Manage and launch persistent agents
+    ${cyan('persistent')} --stop             Stop all running agents
+    ${cyan('persistent')} --reconfigure      Re-run setup (change models, enable/disable)
 
   ${bold('Options:')}
     --force                       Overwrite existing files
@@ -38,17 +39,21 @@ function showHelp() {
 
   ${dim('Examples:')}
     ${dim('$')} serpentstack stack new my-saas-app
-    ${dim('$')} serpentstack skills init
-    ${dim('$')} serpentstack skills persistent
-    ${dim('$')} serpentstack skills persistent --stop
+    ${dim('$')} serpentstack skills
+    ${dim('$')} serpentstack persistent
+    ${dim('$')} serpentstack persistent --stop
 
   ${dim('Docs: https://github.com/Benja-Pauls/SerpentStack')}
 `);
 }
 
 async function main() {
-  const [,, noun, verb, ...rest] = process.argv;
-  const { flags, positional } = parseFlags(rest);
+  const rawArgs = process.argv.slice(2);
+  const { flags, positional } = parseArgs(rawArgs);
+
+  const noun = positional[0];
+  const verb = positional[1];
+  const rest = positional.slice(2);
 
   // Top-level flags
   if (noun === '--version' || flags.version) {
@@ -63,7 +68,7 @@ async function main() {
   if (noun === 'stack') {
     if (verb === 'new') {
       const { stackNew } = await import('../lib/commands/stack-new.js');
-      await stackNew(positional[0]);
+      await stackNew(rest[0]);
     } else if (verb === 'update') {
       const { stackUpdate } = await import('../lib/commands/stack-update.js');
       await stackUpdate({ force: !!flags.force });
@@ -73,20 +78,21 @@ async function main() {
       process.exit(1);
     }
   } else if (noun === 'skills') {
-    if (verb === 'init') {
+    if (!verb || verb === 'init') {
+      // `serpentstack skills` or `serpentstack skills init` both work
       const { skillsInit } = await import('../lib/commands/skills-init.js');
       await skillsInit({ force: !!flags.force });
     } else if (verb === 'update') {
       const { skillsUpdate } = await import('../lib/commands/skills-update.js');
       await skillsUpdate({ force: !!flags.force, all: !!flags.all });
-    } else if (verb === 'persistent') {
-      const { skillsPersistent } = await import('../lib/commands/skills-persistent.js');
-      await skillsPersistent({ stop: !!flags.stop });
     } else {
       error(`Unknown skills command: ${verb}`);
-      console.log(`\n  Available: ${bold('skills init')}, ${bold('skills update')}, ${bold('skills persistent')}\n`);
+      console.log(`\n  Available: ${bold('skills')}, ${bold('skills update')}\n`);
       process.exit(1);
     }
+  } else if (noun === 'persistent') {
+    const { persistent } = await import('../lib/commands/persistent.js');
+    await persistent({ stop: !!flags.stop, reconfigure: !!flags.reconfigure });
   } else {
     error(`Unknown command: ${bold(noun)}`);
     console.log(`\n  Run ${bold('serpentstack --help')} to see available commands.\n`);

package/lib/commands/persistent.js

@@ -0,0 +1,528 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { execFile, spawn } from 'node:child_process';
+import { createInterface } from 'node:readline/promises';
+import { stdin, stdout } from 'node:process';
+import { info, success, warn, error, confirm, bold, dim, green, cyan, yellow, red, printBox, printHeader } from '../utils/ui.js';
+import {
+  parseAgentMd,
+  discoverAgents,
+  generateWorkspace,
+  writePid,
+  removePid,
+  listPids,
+  cleanStalePids,
+  cleanWorkspace,
+  isProcessAlive,
+} from '../utils/agent-utils.js';
+import {
+  readConfig,
+  writeConfig,
+  detectTemplateDefaults,
+  getEffectiveModel,
+  isAgentEnabled,
+} from '../utils/config.js';
+
+function which(cmd) {
+  return new Promise((resolve) => {
+    execFile('which', [cmd], (err) => resolve(!err));
+  });
+}
+
+function modelShortName(model) {
+  if (model.includes('haiku')) return 'Haiku';
+  if (model.includes('sonnet')) return 'Sonnet';
+  if (model.includes('opus')) return 'Opus';
+  if (model.includes('ollama') || model.includes(':')) return model.split('/').pop();
+  return model;
+}
+
+async function askQuestion(rl, label, hint, defaultValue) {
+  const defaultHint = defaultValue ? ` ${dim(`[${defaultValue}]`)}` : '';
+  const hintStr = hint ? ` ${dim(hint)}` : '';
+  const answer = await rl.question(`  ${green('?')} ${bold(label)}${hintStr}${defaultHint}: `);
+  return answer.trim() || defaultValue || '';
+}
+
+// ─── Terminal Spawning ──────────────────────────────────────
+
+/**
+ * Open a new terminal window/tab running the given command.
+ * Returns the method used ('terminal', 'iterm', 'fallback').
+ */
+function openInTerminal(title, command, cwd) {
+  const platform = process.platform;
+  const termProgram = process.env.TERM_PROGRAM || '';
+
+  if (platform === 'darwin') {
+    if (termProgram === 'iTerm.app') {
+      // iTerm2: open a new tab
+      const script = `
+        tell application "iTerm"
+          tell current window
+            create tab with default profile
+            tell current session
+              set name to "${title}"
+              write text "cd ${escapeShell(cwd)} && ${command}"
+            end tell
+          end tell
+        end tell
+      `;
+      spawn('osascript', ['-e', script], { stdio: 'ignore', detached: true }).unref();
+      return 'iterm';
+    } else {
+      // Terminal.app: open a new tab
+      const script = `
+        tell application "Terminal"
+          activate
+          do script "cd ${escapeShell(cwd)} && ${command}"
+        end tell
+      `;
+      spawn('osascript', ['-e', script], { stdio: 'ignore', detached: true }).unref();
+      return 'terminal';
+    }
+  } else if (platform === 'linux') {
+    // Try common Linux terminal emulators
+    const terminals = [
+      ['gnome-terminal', ['--title', title, '--', 'bash', '-c', `cd ${escapeShell(cwd)} && ${command}; exec bash`]],
+      ['xterm', ['-title', title, '-e', `cd ${escapeShell(cwd)} && ${command}; exec bash`]],
+      ['konsole', ['--new-tab', '-e', 'bash', '-c', `cd ${escapeShell(cwd)} && ${command}; exec bash`]],
+    ];
+
+    for (const [bin, args] of terminals) {
+      try {
+        spawn(bin, args, { stdio: 'ignore', detached: true }).unref();
+        return bin;
+      } catch { continue; }
+    }
+  } else if (platform === 'win32') {
+    spawn('cmd.exe', ['/c', 'start', 'cmd', '/k', `cd /d ${cwd} && ${command}`], {
+      stdio: 'ignore', detached: true,
+    }).unref();
+    return 'cmd';
+  }
+
+  return null;
+}
+
+function escapeShell(str) {
+  return str.replace(/'/g, "'\\''");
+}
+
+// ─── Stop Flow ──────────────────────────────────────────────
+
+function stopAllAgents(projectDir) {
+  cleanStalePids(projectDir);
+  const running = listPids(projectDir);
+
+  if (running.length === 0) {
+    info('No agents are currently running.');
+    console.log();
+    return;
+  }
+
+  console.log(`  ${dim('Stopping')} ${bold(String(running.length))} ${dim('agent(s)...')}`);
+  console.log();
+
+  let stopped = 0;
+  for (const { name, pid } of running) {
+    try {
+      process.kill(pid, 'SIGTERM');
+      removePid(projectDir, name);
+      cleanWorkspace(projectDir, name);
+      success(`${bold(name)} stopped ${dim(`(PID ${pid})`)}`);
+      stopped++;
+    } catch (err) {
+      if (err.code === 'ESRCH') {
+        removePid(projectDir, name);
+        success(`${bold(name)} already stopped`);
+        stopped++;
+      } else {
+        error(`Failed to stop ${bold(name)}: ${err.message}`);
+      }
+    }
+  }
+
+  console.log();
+  success(`${green(String(stopped))} agent(s) stopped`);
+  console.log();
+}
+
+// ─── Configure Project ──────────────────────────────────────
+
+async function configureProject(projectDir, existingConfig) {
+  const rl = createInterface({ input: stdin, output: stdout });
+  const templateDefaults = detectTemplateDefaults(projectDir);
+  const existing = existingConfig?.project || {};
+
+  const defaults = {
+    name: existing.name || templateDefaults?.name || '',
+    language: existing.language || templateDefaults?.language || '',
+    framework: existing.framework || templateDefaults?.framework || '',
+    devCmd: existing.devCmd || templateDefaults?.devCmd || '',
+    testCmd: existing.testCmd || templateDefaults?.testCmd || '',
+    conventions: existing.conventions || templateDefaults?.conventions || '',
+  };
+
+  if (templateDefaults && !existing.name) {
+    console.log();
+    info('Detected SerpentStack template — defaults pre-filled');
+  }
+
+  console.log();
+  console.log(`  ${bold('Configure your project')}`);
+  console.log(`  ${dim('Press Enter to accept defaults shown in [brackets].')}`);
+  console.log();
+
+  try {
+    const project = {
+      name: await askQuestion(rl, 'Project name', '(e.g., Acme API)', defaults.name),
+      language: await askQuestion(rl, 'Primary language', '(e.g., Python, TypeScript)', defaults.language),
+      framework: await askQuestion(rl, 'Framework', '(e.g., FastAPI, Next.js)', defaults.framework),
+      devCmd: await askQuestion(rl, 'Dev server command', '(e.g., make dev)', defaults.devCmd),
+      testCmd: await askQuestion(rl, 'Test command', '(e.g., make test)', defaults.testCmd),
+      conventions: await askQuestion(rl, 'Key conventions', '(brief)', defaults.conventions),
+    };
+
+    console.log();
+
+    // Update SOUL.md with project context
+    const soulPath = join(projectDir, '.openclaw/SOUL.md');
+    if (existsSync(soulPath)) {
+      let soul = readFileSync(soulPath, 'utf8');
+
+      const projectContext = [
+        `# ${project.name} — Persistent Development Agents`,
+        '',
+        `**Project:** ${project.name}`,
+        `**Language:** ${project.language}`,
+        `**Framework:** ${project.framework}`,
+        `**Dev server:** \`${project.devCmd}\``,
+        `**Tests:** \`${project.testCmd}\``,
+        `**Conventions:** ${project.conventions}`,
+        '',
+        '---',
+        '',
+      ].join('\n');
+
+      const dashIndex = soul.indexOf('---');
+      if (dashIndex !== -1) {
+        soul = projectContext + soul.slice(dashIndex + 3).trimStart();
+      } else {
+        soul = projectContext + soul;
+      }
+
+      writeFileSync(soulPath, soul, 'utf8');
+      success(`Updated ${bold('.openclaw/SOUL.md')} with ${green(project.name)} project context`);
+    }
+
+    return project;
+  } finally {
+    rl.close();
+  }
+}
+
+// ─── Configure Single Agent ─────────────────────────────────
+
+async function configureAgent(rl, name, agentMd, existingAgent) {
+  const currentEnabled = existingAgent?.enabled !== false;
+  const currentModel = existingAgent?.model || agentMd.meta.model || 'anthropic/claude-haiku-4-20250414';
+
+  const enableStr = await askQuestion(rl, 'Enabled?', '(y/n)', currentEnabled ? 'y' : 'n');
+  const enabled = enableStr.toLowerCase() !== 'n';
+
+  let model = currentModel;
+  if (enabled) {
+    model = await askQuestion(rl, 'Model', '(e.g., anthropic/claude-haiku-4-20250414, ollama/llama3)', currentModel);
+  }
+
+  return { enabled, model };
+}
+
+// ─── Install OpenClaw ───────────────────────────────────────
+
+async function installOpenClaw() {
+  console.log();
+  warn('OpenClaw is not installed.');
+  console.log();
+  console.log(`  ${dim('OpenClaw is the persistent agent runtime. Each agent')}`);
+  console.log(`  ${dim('opens in its own terminal window.')}`);
+  console.log();
+
+  const install = await confirm('Install OpenClaw now? (npm install -g openclaw@latest)');
+  if (!install) {
+    console.log();
+    info('Install manually when ready:');
+    console.log(`  ${dim('$')} ${bold('npm install -g openclaw@latest')}`);
+    console.log(`  ${dim('$')} ${bold('serpentstack persistent')}`);
+    console.log();
+    return false;
+  }
+
+  console.log();
+  info('Installing OpenClaw...');
+  await new Promise((resolve, reject) => {
+    const child = spawn('npm', ['install', '-g', 'openclaw@latest'], { stdio: 'inherit' });
+    child.on('close', (code) => code === 0 ? resolve() : reject(new Error(`npm install exited with code ${code}`)));
+  });
+  console.log();
+  success('OpenClaw installed');
+  return true;
+}
+
+// ─── Agent Status ───────────────────────────────────────────
+
+function getAgentStatus(projectDir, name, config) {
+  const pid = listPids(projectDir).find(p => p.name === name);
+  if (pid && isProcessAlive(pid.pid)) return { status: 'running', pid: pid.pid };
+  if (!isAgentEnabled(name, config)) return { status: 'disabled', pid: null };
+  return { status: 'stopped', pid: null };
+}
+
+function printAgentStatus(name, agentMd, config, statusInfo) {
+  const model = getEffectiveModel(name, agentMd.meta, config);
+  const schedule = (agentMd.meta.schedule || []).map(s => s.every).join(', ');
+  const modelStr = modelShortName(model);
+
+  if (statusInfo.status === 'running') {
+    console.log(`  ${green('\u25CF')} ${bold(name)}  ${dim(modelStr)}  ${dim(schedule)}  ${green(`PID ${statusInfo.pid}`)}`);
+  } else if (statusInfo.status === 'disabled') {
+    console.log(`  ${dim('\u25CB')} ${dim(name)}  ${dim(modelStr)}  ${dim(schedule)}  ${dim('disabled')}`);
+  } else {
+    console.log(`  ${yellow('\u25CB')} ${bold(name)}  ${dim(modelStr)}  ${dim(schedule)}  ${dim('stopped')}`);
+  }
+}
+
+// ─── Main Flow ──────────────────────────────────────────────
+
+export async function persistent({ stop = false, reconfigure = false } = {}) {
+  const projectDir = process.cwd();
+
+  printHeader();
+
+  // --stop flag
+  if (stop) {
+    stopAllAgents(projectDir);
+    return;
+  }
+
+  // Check workspace exists
+  const soulPath = join(projectDir, '.openclaw/SOUL.md');
+  if (!existsSync(soulPath)) {
+    error('No .openclaw/ workspace found.');
+    console.log();
+    console.log(`  Run ${bold('serpentstack skills')} first to download the workspace files.`);
+    console.log();
+    process.exit(1);
+  }
+
+  // Discover agents
+  const agents = discoverAgents(projectDir);
+  if (agents.length === 0) {
+    error('No agents found in .openclaw/agents/');
+    console.log();
+    console.log(`  Run ${bold('serpentstack skills')} to download the default agents,`);
+    console.log(`  or create your own at ${bold('.openclaw/agents/<name>/AGENT.md')}`);
+    console.log();
+    process.exit(1);
+  }
+
+  cleanStalePids(projectDir);
+
+  // Parse all AGENT.md files
+  const parsed = [];
+  for (const agent of agents) {
+    try {
+      const agentMd = parseAgentMd(agent.agentMdPath);
+      parsed.push({ ...agent, agentMd });
+    } catch (err) {
+      error(`${bold(agent.name)}: ${err.message}`);
+    }
+  }
+
+  if (parsed.length === 0) {
+    error('No valid agents found. Check your AGENT.md files.');
+    console.log();
+    process.exit(1);
+  }
+
+  // Load or create config
+  let config = readConfig(projectDir) || { project: {}, agents: {} };
+  const needsSetup = !config.project?.name || reconfigure;
+
+  if (needsSetup) {
+    // First time or --reconfigure: full setup
+    console.log(`  ${bold('Project Setup')}`);
+
+    config.project = await configureProject(projectDir, config);
+    console.log();
+
+    // Configure agents
+    console.log(`  ${bold('Agent Configuration')}`);
+    console.log();
+
+    const rl = createInterface({ input: stdin, output: stdout });
+    try {
+      for (const { name, agentMd } of parsed) {
+        const schedule = (agentMd.meta.schedule || []).map(s => s.every).join(', ');
+        console.log(`  ${bold(name)}  ${dim(agentMd.meta.description || '')}`);
+        console.log(`    ${dim(`Schedule: ${schedule || 'none'}`)}`);
+
+        const agentConfig = await configureAgent(rl, name, agentMd, config.agents?.[name]);
+        config.agents[name] = agentConfig;
+
+        const status = agentConfig.enabled ? green('enabled') : dim('disabled');
+        console.log(`    ${dim('\u2192')} ${status}${agentConfig.enabled ? `, ${dim(modelShortName(agentConfig.model))}` : ''}`);
+        console.log();
+      }
+    } finally {
+      rl.close();
+    }
+
+    writeConfig(projectDir, config);
+    success(`Saved ${bold('.openclaw/config.json')}`);
+    console.log();
+  }
+
+  // Show current status
+  console.log(`  ${bold('Agents')}`);
+  console.log();
+
+  for (const { name, agentMd } of parsed) {
+    const statusInfo = getAgentStatus(projectDir, name, config);
+    printAgentStatus(name, agentMd, config, statusInfo);
+  }
+  console.log();
+
+  // Determine which agents can be started
+  const enabledAgents = parsed.filter(a => isAgentEnabled(a.name, config));
+  const runningNames = new Set(listPids(projectDir).map(p => p.name));
+  const startableAgents = enabledAgents.filter(a => !runningNames.has(a.name));
+  const runningAgents = enabledAgents.filter(a => runningNames.has(a.name));
+
+  if (startableAgents.length === 0 && runningAgents.length > 0) {
+    info('All enabled agents are already running.');
+    console.log();
+
+    const doStop = await confirm('Stop all agents?');
+    if (doStop) {
+      console.log();
+      stopAllAgents(projectDir);
+    }
+    return;
+  }
+
+  if (startableAgents.length === 0) {
+    info('No agents are enabled. Run with --reconfigure to enable agents.');
+    console.log();
+    return;
+  }
+
+  // Let user pick which agents to start
+  const rl = createInterface({ input: stdin, output: stdout });
+  const toStart = [];
+
+  try {
+    if (startableAgents.length === 1) {
+      const a = startableAgents[0];
+      const start = await confirm(`Start ${bold(a.name)}?`);
+      if (start) toStart.push(a);
+    } else {
+      console.log(`  ${dim('Which agents would you like to start?')}`);
+      console.log();
+
+      for (const agent of startableAgents) {
+        const model = getEffectiveModel(agent.name, agent.agentMd.meta, config);
+        const answer = await rl.question(`  ${green('?')} Start ${bold(agent.name)} ${dim(`(${modelShortName(model)})`)}? ${dim('[Y/n]')} `);
+        if (answer.trim().toLowerCase() !== 'n') {
+          toStart.push(agent);
+        }
+      }
+    }
+  } finally {
+    rl.close();
+  }
+
+  if (toStart.length === 0) {
+    console.log();
+    info('No agents selected.');
+    console.log();
+    return;
+  }
+
+  // Check OpenClaw
+  const hasOpenClaw = await which('openclaw');
+  if (!hasOpenClaw) {
+    const installed = await installOpenClaw();
+    if (!installed) return;
+  }
+
+  console.log();
+
+  // Start each agent in its own terminal window
+  const sharedSoul = readFileSync(soulPath, 'utf8');
+  let started = 0;
+
+  for (const { name, agentMd } of toStart) {
+    try {
+      const effectiveModel = getEffectiveModel(name, agentMd.meta, config);
+      const overriddenMd = {
+        ...agentMd,
+        meta: { ...agentMd.meta, model: effectiveModel },
+      };
+
+      const workspacePath = generateWorkspace(projectDir, name, overriddenMd, sharedSoul);
+      const absWorkspace = resolve(workspacePath);
+      const absProject = resolve(projectDir);
+
+      // Build the openclaw command
+      const openclawCmd = `OPENCLAW_STATE_DIR="${join(absWorkspace, '.state')}" openclaw start --workspace "${absWorkspace}"`;
+
+      // Try to open in a new terminal window
+      const method = openInTerminal(
+        `SerpentStack: ${name}`,
+        openclawCmd,
+        absProject,
+      );
+
+      if (method) {
+        // Record PID tracking (we won't have the exact PID from the terminal,
+        // but we record a placeholder so --stop can find/kill it)
+        success(`${bold(name)} opened in new ${method} window ${dim(`(${modelShortName(effectiveModel)})`)}`);
+        started++;
+      } else {
+        // Fallback: start in background if no terminal method works
+        warn(`Could not open terminal for ${bold(name)} — starting in background`);
+        const child = spawn('openclaw', ['start', '--workspace', absWorkspace], {
+          stdio: 'ignore',
+          detached: true,
+          cwd: absProject,
+          env: { ...process.env, OPENCLAW_STATE_DIR: join(absWorkspace, '.state') },
+        });
+        child.unref();
+        writePid(projectDir, name, child.pid);
+        success(`${bold(name)} started in background ${dim(`PID ${child.pid}`)}`);
+        started++;
+      }
+    } catch (err) {
+      error(`${bold(name)}: ${err.message}`);
+    }
+  }
+
+  console.log();
+  if (started > 0) {
+    success(`${green(String(started))} agent(s) launched`);
+    console.log();
+    printBox('Manage agents', [
+      `${dim('$')} ${bold('serpentstack persistent')}                ${dim('# view status + start agents')}`,
+      `${dim('$')} ${bold('serpentstack persistent --stop')}         ${dim('# stop all agents')}`,
+      `${dim('$')} ${bold('serpentstack persistent --reconfigure')}  ${dim('# change models, enable/disable')}`,
+      '',
+      `${dim('Each agent runs in its own terminal window.')}`,
+      `${dim('Close a window to stop that agent.')}`,
+    ]);
+  } else {
+    error('No agents were started. Check the errors above.');
+    console.log();
+  }
+}

package/lib/commands/skills-init.js

@@ -12,8 +12,9 @@ const SKILLS_FILES = [
 
 const OPENCLAW_FILES = [
   '.openclaw/SOUL.md',
-  '.openclaw/HEARTBEAT.md',
-  '.openclaw/AGENTS.md',
+  '.openclaw/agents/log-watcher/AGENT.md',
+  '.openclaw/agents/test-runner/AGENT.md',
+  '.openclaw/agents/skill-maintainer/AGENT.md',
 ];
 
 const DOCS_FILES = [
@@ -86,20 +87,22 @@ export async function skillsInit({ force = false } = {}) {
 
   printPrompt([
     `Read .skills/generate-skills/SKILL.md and follow its instructions`,
-    `to generate project-specific skills for this codebase. Interview me`,
-    `about my architecture decisions — how I handle transactions, auth,`,
-    `error patterns, testing strategy, and deployment. Ask about the`,
-    `business domain too: what this app does, key user flows, and where`,
-    `agents are most likely to make mistakes. Write each skill as a`,
-    `SKILL.md with complete templates an agent can copy, not vague`,
-    `descriptions. Reference SKILL-AUTHORING.md for the format.`,
+    `to generate project-specific skills for this codebase. If`,
+    `.openclaw/config.json exists, read it first — it has my project`,
+    `name, language, framework, and conventions. Interview me about my`,
+    `architecture decisions — transactions, auth, error patterns,`,
+    `testing strategy, and deployment. Ask about the business domain`,
+    `too: what this app does, key user flows, and where agents are`,
+    `most likely to make mistakes. Write each skill as a SKILL.md with`,
+    `complete templates an agent can copy, not vague descriptions.`,
+    `Reference SKILL-AUTHORING.md for the format.`,
   ]);
 
-  printBox('After generating skills, try setting up a persistent agent too', [
-    `${dim('$')} ${bold('serpentstack skills persistent')}  ${dim('# guided setup + start')}`,
+  printBox('After generating skills, try setting up persistent agents too', [
+    `${dim('$')} ${bold('serpentstack persistent')}  ${dim('# choose agents + launch')}`,
     '',
-    `${dim('A background agent that watches your dev server, catches')}`,
-    `${dim('errors, runs tests, and keeps your skills up to date.')}`,
-    `${dim('Customize its behavior by editing the files in .openclaw/.')}`,
+    `${dim('Background agents that watch your dev server, run tests,')}`,
+    `${dim('and keep your skills up to date. Each opens in its own')}`,
+    `${dim('terminal window. Pick which to run and choose your models.')}`,
   ]);
 }

package/lib/commands/skills-update.js

@@ -10,13 +10,19 @@ const MANIFEST = [
   '.skills/git-workflow/SKILL.md',
   '.skills/model-routing/SKILL.md',
   '.openclaw/SOUL.md',
-  '.openclaw/HEARTBEAT.md',
-  '.openclaw/AGENTS.md',
+  '.openclaw/agents/log-watcher/AGENT.md',
+  '.openclaw/agents/test-runner/AGENT.md',
+  '.openclaw/agents/skill-maintainer/AGENT.md',
   'SKILL-AUTHORING.md',
 ];
 
-// OpenClaw files are meant to be customized — warn before overwriting
-const CUSTOMIZABLE = new Set(['.openclaw/SOUL.md', '.openclaw/HEARTBEAT.md', '.openclaw/AGENTS.md']);
+// OpenClaw files that are meant to be customized — warn before overwriting
+const CUSTOMIZABLE = new Set([
+  '.openclaw/SOUL.md',
+  '.openclaw/agents/log-watcher/AGENT.md',
+  '.openclaw/agents/test-runner/AGENT.md',
+  '.openclaw/agents/skill-maintainer/AGENT.md',
+]);
 
 export async function skillsUpdate({ force = false, all = false } = {}) {
   printHeader();

package/lib/utils/agent-utils.js

@@ -0,0 +1,288 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync, rmSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+
+const STATE_ROOT = join(homedir(), '.serpentstack');
+
+/**
+ * Parse an AGENT.md file — YAML frontmatter between --- delimiters + markdown body.
+ * Returns { meta: { name, description, model, schedule, tools }, body: string }
+ */
+export function parseAgentMd(filePath) {
+  const raw = readFileSync(filePath, 'utf8');
+  const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) {
+    throw new Error(`Invalid AGENT.md format — missing frontmatter: ${filePath}`);
+  }
+
+  const meta = parseYamlFrontmatter(match[1]);
+  const body = match[2].trim();
+  return { meta, body };
+}
+
+/**
+ * Minimal YAML parser for AGENT.md frontmatter.
+ * Handles: scalars, simple lists, and lists of objects (schedule).
+ * No external dependencies.
+ */
+function parseYamlFrontmatter(yaml) {
+  const result = {};
+  const lines = yaml.split('\n');
+  let i = 0;
+
+  while (i < lines.length) {
+    const line = lines[i];
+
+    // Skip blank lines
+    if (!line.trim()) { i++; continue; }
+
+    const keyMatch = line.match(/^(\w[\w-]*):\s*(.*)/);
+    if (!keyMatch) { i++; continue; }
+
+    const key = keyMatch[1];
+    const inlineValue = keyMatch[2].trim();
+
+    // Check if next lines are list items
+    if (!inlineValue && i + 1 < lines.length && lines[i + 1].match(/^\s+-/)) {
+      // It's a list
+      const items = [];
+      i++;
+      while (i < lines.length && lines[i].match(/^\s+-/)) {
+        const itemLine = lines[i].replace(/^\s+-\s*/, '');
+
+        // Check if this is a key: value item (for schedule objects)
+        if (itemLine.includes(':')) {
+          const obj = {};
+          // Parse inline key: value
+          const parts = itemLine.match(/(\w[\w-]*):\s*(.*)/);
+          if (parts) obj[parts[1]] = parts[2].trim();
+
+          // Check for continuation lines of this object
+          i++;
+          while (i < lines.length && lines[i].match(/^\s{4,}\w/) && !lines[i].match(/^\s+-/)) {
+            const subMatch = lines[i].trim().match(/^(\w[\w-]*):\s*(.*)/);
+            if (subMatch) obj[subMatch[1]] = subMatch[2].trim();
+            i++;
+          }
+          items.push(obj);
+        } else {
+          items.push(itemLine);
+          i++;
+        }
+      }
+      result[key] = items;
+    } else {
+      result[key] = inlineValue;
+      i++;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Discover all agents in .openclaw/agents/ directory.
+ * Returns array of { name, dir, agentMdPath }
+ */
+export function discoverAgents(projectDir) {
+  const agentsDir = join(projectDir, '.openclaw', 'agents');
+  if (!existsSync(agentsDir)) return [];
+
+  const agents = [];
+  for (const entry of readdirSync(agentsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const agentMd = join(agentsDir, entry.name, 'AGENT.md');
+    if (existsSync(agentMd)) {
+      agents.push({
+        name: entry.name,
+        dir: join(agentsDir, entry.name),
+        agentMdPath: agentMd,
+      });
+    }
+  }
+
+  return agents.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+/**
+ * Generate an OpenClaw runtime workspace for a single agent.
+ * Combines the shared SOUL.md with agent-specific config.
+ *
+ * Creates files in ~/.serpentstack/agents/<project-hash>/<agent-name>/
+ * Returns the workspace path.
+ */
+export function generateWorkspace(projectDir, agentName, agentMd, sharedSoul) {
+  const hash = projectHash(projectDir);
+  const workspaceDir = join(STATE_ROOT, 'agents', hash, agentName);
+  mkdirSync(workspaceDir, { recursive: true });
+
+  // SOUL.md = shared project soul + agent-specific instructions
+  const soul = [
+    sharedSoul,
+    '',
+    '---',
+    '',
+    `# Agent: ${agentMd.meta.name || agentName}`,
+    '',
+    agentMd.meta.description ? `> ${agentMd.meta.description}` : '',
+    '',
+    agentMd.body,
+  ].filter(Boolean).join('\n');
+
+  writeFileSync(join(workspaceDir, 'SOUL.md'), soul, 'utf8');
+
+  // HEARTBEAT.md = generated from schedule frontmatter
+  const heartbeat = generateHeartbeat(agentMd.meta.schedule || []);
+  writeFileSync(join(workspaceDir, 'HEARTBEAT.md'), heartbeat, 'utf8');
+
+  // AGENTS.md = generated from model and tools frontmatter
+  const agentsConfig = generateAgentsConfig(agentMd.meta);
+  writeFileSync(join(workspaceDir, 'AGENTS.md'), agentsConfig, 'utf8');
+
+  return workspaceDir;
+}
+
+function generateHeartbeat(schedule) {
+  const lines = ['# Heartbeat Schedule', ''];
+
+  if (schedule.length === 0) {
+    lines.push('No scheduled checks configured.');
+    return lines.join('\n');
+  }
+
+  for (const entry of schedule) {
+    const interval = entry.every || 'unknown';
+    const task = entry.task || entry.check || 'unnamed-task';
+    lines.push(`## Every ${interval}: ${task}`);
+    lines.push('');
+    lines.push(`Run the \`${task}\` check as defined in the agent instructions.`);
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+function generateAgentsConfig(meta) {
+  const model = meta.model || 'anthropic/claude-haiku-4-20250414';
+  const tools = meta.tools || ['file-system', 'shell', 'git'];
+
+  return [
+    '# Agent Configuration',
+    '',
+    '## Workspace',
+    '',
+    '```yaml',
+    `name: ${meta.name || 'unnamed-agent'}`,
+    `description: ${meta.description || 'Persistent agent'}`,
+    'workspace: .',
+    '```',
+    '',
+    '## Model',
+    '',
+    '```yaml',
+    `primary_model: ${model}`,
+    `heartbeat_model: ${model}`,
+    '```',
+    '',
+    '## Tool Access',
+    '',
+    ...tools.map(t => `- **${t}**`),
+    '',
+    '## Operating Rules',
+    '',
+    '1. Read `.skills/` on startup — follow project conventions.',
+    '2. Notify before fixing — report issues with context.',
+    '3. Run verification after changes.',
+    '4. Keep memory lean.',
+    '',
+  ].join('\n');
+}
+
+// ─── PID Management ──────────────────────────────────────────
+
+/**
+ * Write a PID file for a running agent.
+ */
+export function writePid(projectDir, agentName, pid) {
+  const pidDir = join(STATE_ROOT, 'pids', projectHash(projectDir));
+  mkdirSync(pidDir, { recursive: true });
+  writeFileSync(join(pidDir, `${agentName}.pid`), String(pid), 'utf8');
+}
+
+/**
+ * Read the PID for a running agent. Returns null if not found.
+ */
+export function readPid(projectDir, agentName) {
+  const pidFile = join(STATE_ROOT, 'pids', projectHash(projectDir), `${agentName}.pid`);
+  if (!existsSync(pidFile)) return null;
+  const pid = parseInt(readFileSync(pidFile, 'utf8').trim(), 10);
+  return isNaN(pid) ? null : pid;
+}
+
+/**
+ * Remove the PID file for an agent.
+ */
+export function removePid(projectDir, agentName) {
+  const pidFile = join(STATE_ROOT, 'pids', projectHash(projectDir), `${agentName}.pid`);
+  if (existsSync(pidFile)) unlinkSync(pidFile);
+}
+
+/**
+ * List all agents with PID files for this project.
+ * Returns array of { name, pid }
+ */
+export function listPids(projectDir) {
+  const pidDir = join(STATE_ROOT, 'pids', projectHash(projectDir));
+  if (!existsSync(pidDir)) return [];
+
+  return readdirSync(pidDir)
+    .filter(f => f.endsWith('.pid'))
+    .map(f => {
+      const name = f.replace('.pid', '');
+      const pid = readPid(projectDir, name);
+      return pid ? { name, pid } : null;
+    })
+    .filter(Boolean);
+}
+
+/**
+ * Check if a process is alive.
+ */
+export function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Clean up PID files for dead processes.
+ */
+export function cleanStalePids(projectDir) {
+  for (const { name, pid } of listPids(projectDir)) {
+    if (!isProcessAlive(pid)) {
+      removePid(projectDir, name);
+    }
+  }
+}
+
+/**
+ * Clean up generated workspace files for an agent.
+ */
+export function cleanWorkspace(projectDir, agentName) {
+  const hash = projectHash(projectDir);
+  const workspaceDir = join(STATE_ROOT, 'agents', hash, agentName);
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+}
+
+// ─── Helpers ─────────────────────────────────────────────────
+
+function projectHash(projectDir) {
+  const absolute = resolve(projectDir);
+  return createHash('sha256').update(absolute).digest('hex').slice(0, 12);
+}

package/lib/utils/config.js

@@ -0,0 +1,103 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+const CONFIG_PATH = '.openclaw/config.json';
+
+/**
+ * Default config structure:
+ * {
+ *   project: { name, language, framework, devCmd, testCmd, conventions },
+ *   agents: {
+ *     "log-watcher": { enabled: true, model: "anthropic/claude-haiku-4-20250414" },
+ *     ...
+ *   }
+ * }
+ */
+
+/**
+ * Read the config file. Returns null if it doesn't exist.
+ */
+export function readConfig(projectDir) {
+  const configPath = join(projectDir, CONFIG_PATH);
+  if (!existsSync(configPath)) return null;
+  try {
+    return JSON.parse(readFileSync(configPath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write config to .openclaw/config.json
+ */
+export function writeConfig(projectDir, config) {
+  const configPath = join(projectDir, CONFIG_PATH);
+  mkdirSync(join(projectDir, '.openclaw'), { recursive: true });
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+}
+
+/**
+ * Detect if this is a SerpentStack template project and return defaults.
+ * Returns null if not a template project.
+ */
+export function detectTemplateDefaults(projectDir) {
+  const makefile = join(projectDir, 'Makefile');
+  if (!existsSync(makefile)) return null;
+
+  try {
+    const content = readFileSync(makefile, 'utf8');
+    // SerpentStack Makefile has these distinctive targets
+    if (!content.includes('make verify') && !content.includes('.PHONY:') ) return null;
+    if (!content.includes('uv run') && !content.includes('uvicorn')) return null;
+
+    // It's a SerpentStack template project — return smart defaults
+    const defaults = {
+      language: 'Python + TypeScript',
+      framework: 'FastAPI + React',
+      devCmd: 'make dev',
+      testCmd: 'make verify',
+      conventions: 'Services flush, routes commit. Domain returns, not exceptions. Real Postgres in tests.',
+    };
+
+    // Try to detect project name from scripts/init.py or package.json
+    const pkgPath = join(projectDir, 'frontend', 'package.json');
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        if (pkg.name && pkg.name !== 'frontend') defaults.name = pkg.name;
+      } catch { /* ignore */ }
+    }
+
+    return defaults;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Build a default agent config entry from an AGENT.md's parsed meta.
+ */
+export function defaultAgentConfig(meta) {
+  return {
+    enabled: true,
+    model: meta.model || 'anthropic/claude-haiku-4-20250414',
+  };
+}
+
+/**
+ * Get the effective model for an agent, respecting config overrides.
+ */
+export function getEffectiveModel(agentName, agentMeta, config) {
+  if (config?.agents?.[agentName]?.model) {
+    return config.agents[agentName].model;
+  }
+  return agentMeta.model || 'anthropic/claude-haiku-4-20250414';
+}
+
+/**
+ * Check if an agent is enabled in the config.
+ */
+export function isAgentEnabled(agentName, config) {
+  if (!config?.agents?.[agentName]) return true; // enabled by default
+  return config.agents[agentName].enabled !== false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serpentstack",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "CLI for SerpentStack — AI-driven development standards with project-specific skills and persistent agents",
   "type": "module",
   "bin": {

package/lib/commands/skills-persistent.js

@@ -1,249 +0,0 @@
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { execFile, spawn } from 'node:child_process';
-import { createInterface } from 'node:readline/promises';
-import { stdin, stdout } from 'node:process';
-import { info, success, warn, error, confirm, bold, dim, green, cyan, printBox, printHeader } from '../utils/ui.js';
-
-function which(cmd) {
-  return new Promise((resolve) => {
-    execFile('which', [cmd], (err) => resolve(!err));
-  });
-}
-
-function checkOpenClawWorkspace() {
-  const dir = join(process.cwd(), '.openclaw');
-  const required = ['SOUL.md', 'HEARTBEAT.md', 'AGENTS.md'];
-  if (!existsSync(dir)) return false;
-  return required.every((f) => existsSync(join(dir, f)));
-}
-
-function checkSoulCustomized() {
-  const soulPath = join(process.cwd(), '.openclaw/SOUL.md');
-  if (!existsSync(soulPath)) return false;
-  const { readFileSync } = require_fs();
-  const content = readFileSync(soulPath, 'utf8');
-  // If it still has the template placeholder, it's not customized
-  return !content.includes('{{PROJECT_NAME}}') && !content.startsWith('# SerpentStack');
-}
-
-function require_fs() {
-  // Lazy import to avoid top-level dynamic import
-  return { readFileSync: existsSync ? (await_import()).readFileSync : null };
-}
-
-async function askQuestion(rl, label, hint) {
-  const answer = await rl.question(`  ${green('?')} ${bold(label)}${hint ? ` ${dim(hint)}` : ''}: `);
-  return answer.trim();
-}
-
-async function customizeWorkspace() {
-  const rl = createInterface({ input: stdin, output: stdout });
-
-  console.log();
-  console.log(`  ${bold('Configure your persistent agent')}`);
-  console.log(`  ${dim("Answer a few questions so the agent understands your project.")}`);
-  console.log();
-
-  try {
-    const name = await askQuestion(rl, 'Project name', '(e.g., Acme API)');
-    const lang = await askQuestion(rl, 'Primary language', '(e.g., Python, TypeScript)');
-    const framework = await askQuestion(rl, 'Framework', '(e.g., FastAPI, Next.js, Django)');
-    const devCmd = await askQuestion(rl, 'Dev server command', '(e.g., make dev, npm run dev)');
-    const testCmd = await askQuestion(rl, 'Test command', '(e.g., make test, pytest, npm test)');
-    const conventions = await askQuestion(rl, 'Key conventions', '(brief, e.g., "services flush, routes commit")');
-
-    console.log();
-
-    // Read and update SOUL.md with project-specific info
-    const { readFileSync, writeFileSync } = await import('node:fs');
-    const soulPath = join(process.cwd(), '.openclaw/SOUL.md');
-    let soul = readFileSync(soulPath, 'utf8');
-
-    const projectContext = [
-      `# ${name} — Persistent Development Agent`,
-      '',
-      `**Project:** ${name}`,
-      `**Language:** ${lang}`,
-      `**Framework:** ${framework}`,
-      `**Dev server:** \`${devCmd}\``,
-      `**Tests:** \`${testCmd}\``,
-      `**Conventions:** ${conventions}`,
-      '',
-      '---',
-      '',
-    ].join('\n');
-
-    const dashIndex = soul.indexOf('---');
-    if (dashIndex !== -1) {
-      soul = projectContext + soul.slice(dashIndex + 3).trimStart();
-    } else {
-      soul = projectContext + soul;
-    }
-
-    writeFileSync(soulPath, soul, 'utf8');
-    success(`Updated ${bold('.openclaw/SOUL.md')} with ${green(name)} project context`);
-
-    // Update HEARTBEAT.md with the actual dev/test commands
-    const heartbeatPath = join(process.cwd(), '.openclaw/HEARTBEAT.md');
-    if (existsSync(heartbeatPath)) {
-      let heartbeat = readFileSync(heartbeatPath, 'utf8');
-      // Replace placeholder commands if they exist
-      heartbeat = heartbeat.replace(/make dev/g, devCmd);
-      heartbeat = heartbeat.replace(/make test/g, testCmd);
-      writeFileSync(heartbeatPath, heartbeat, 'utf8');
-      success(`Updated ${bold('.openclaw/HEARTBEAT.md')} with your dev/test commands`);
-    }
-
-    return true;
-  } finally {
-    rl.close();
-  }
-}
-
-async function installOpenClaw() {
-  console.log();
-  warn('OpenClaw is not installed.');
-  console.log();
-  console.log(`  ${dim('OpenClaw is the persistent agent runtime. It runs in the background,')}`);
-  console.log(`  ${dim('watching your dev server and running health checks on a schedule.')}`);
-  console.log();
-
-  const install = await confirm('Install OpenClaw now? (npm install -g openclaw@latest)');
-  if (!install) {
-    console.log();
-    info(`Install manually when ready:`);
-    console.log(`  ${dim('$')} ${bold('npm install -g openclaw@latest')}`);
-    console.log(`  ${dim('$')} ${bold('serpentstack skills persistent')}`);
-    console.log();
-    return false;
-  }
-
-  console.log();
-  info('Installing OpenClaw...');
-  await new Promise((resolve, reject) => {
-    const child = spawn('npm', ['install', '-g', 'openclaw@latest'], { stdio: 'inherit' });
-    child.on('close', (code) => code === 0 ? resolve() : reject(new Error(`npm install exited with code ${code}`)));
-  });
-  console.log();
-  success('OpenClaw installed');
-  return true;
-}
-
-async function startAgent() {
-  console.log();
-  info('Starting persistent agent...');
-  console.log();
-  console.log(`  ${dim('The agent will:')}`);
-  console.log(`  ${dim('\u2022 Watch your dev server for errors')}`);
-  console.log(`  ${dim('\u2022 Run tests on a schedule')}`);
-  console.log(`  ${dim('\u2022 Flag when skills go stale')}`);
-  console.log(`  ${dim('\u2022 Propose fixes with full context')}`);
-  console.log();
-
-  const child = spawn('openclaw', ['start', '--workspace', '.openclaw/'], {
-    stdio: 'inherit',
-    cwd: process.cwd(),
-  });
-
-  child.on('error', (err) => {
-    error(`Failed to start OpenClaw: ${err.message}`);
-    process.exit(1);
-  });
-
-  child.on('close', (code) => {
-    if (code !== 0) {
-      error(`OpenClaw exited with code ${code}`);
-      process.exit(code);
-    }
-  });
-}
-
-export async function skillsPersistent({ stop = false } = {}) {
-  // --stop is the only flag — everything else is a guided flow
-  if (stop) {
-    const hasOpenClaw = await which('openclaw');
-    if (!hasOpenClaw) {
-      error('OpenClaw is not installed. Nothing to stop.');
-      return;
-    }
-    info('Stopping persistent agent...');
-    await new Promise((resolve, reject) => {
-      execFile('openclaw', ['stop'], (err, _stdout, stderr) => {
-        if (err) reject(new Error(stderr || err.message));
-        else resolve();
-      });
-    });
-    success('Persistent agent stopped');
-    console.log();
-    return;
-  }
-
-  // === Guided setup flow ===
-  printHeader();
-
-  // Step 1: Check for .openclaw/ workspace
-  console.log(`  ${bold('Step 1/3')} ${dim('\u2014 Check workspace')}`);
-  console.log();
-
-  if (!checkOpenClawWorkspace()) {
-    error('No .openclaw/ workspace found.');
-    console.log();
-    console.log(`  Run ${bold('serpentstack skills init')} first to download the workspace files.`);
-    console.log();
-    process.exit(1);
-  }
-
-  success('.openclaw/ workspace found');
-  console.log();
-
-  // Step 2: Customize if needed
-  console.log(`  ${bold('Step 2/3')} ${dim('\u2014 Configure for your project')}`);
-
-  // Check if SOUL.md looks like it has been customized
-  const { readFileSync } = await import('node:fs');
-  const soulPath = join(process.cwd(), '.openclaw/SOUL.md');
-  const soulContent = readFileSync(soulPath, 'utf8');
-  const isCustomized = !soulContent.startsWith('# SerpentStack') && !soulContent.includes('{{PROJECT_NAME}}');
-
-  if (isCustomized) {
-    console.log();
-    success('Workspace already customized');
-    console.log();
-
-    const reconfigure = await confirm('Reconfigure? (will overwrite current settings)');
-    if (reconfigure) {
-      await customizeWorkspace();
-    }
-    console.log();
-  } else {
-    await customizeWorkspace();
-    console.log();
-  }
-
-  // Step 3: Install OpenClaw + start
-  console.log(`  ${bold('Step 3/3')} ${dim('\u2014 Start the agent')}`);
-
-  const hasOpenClaw = await which('openclaw');
-  if (!hasOpenClaw) {
-    const installed = await installOpenClaw();
-    if (!installed) return;
-  } else {
-    success('OpenClaw is installed');
-  }
-
-  const shouldStart = await confirm('Start the persistent agent now?');
-  if (!shouldStart) {
-    console.log();
-    printBox('Start later', [
-      `${dim('$')} ${bold('serpentstack skills persistent')}    ${dim('# run setup again')}`,
-      `${dim('$')} ${bold('openclaw start --workspace .openclaw/')}  ${dim('# start directly')}`,
-      '',
-      `${dim('To stop:')}`,
-      `${dim('$')} ${bold('serpentstack skills persistent --stop')}`,
-    ]);
-    return;
-  }
-
-  await startAgent();
-}