serpentstack 0.2.5 → 0.2.6

package/bin/serpentstack.js

@@ -2,6 +2,9 @@
 
 import { error, bold, dim, green, cyan, getVersion, printHeader } from '../lib/utils/ui.js';
 
+// Short flag aliases
+const FLAG_ALIASES = { f: 'force', h: 'help', v: 'version', a: 'all' };
+
 function parseArgs(args) {
   const flags = {};
   const positional = [];
@@ -9,6 +12,13 @@ function parseArgs(args) {
     if (arg.startsWith('--')) {
       const [key, val] = arg.slice(2).split('=');
       flags[key] = val ?? true;
+    } else if (arg.startsWith('-') && arg.length > 1 && !arg.startsWith('--')) {
+      // Short flags: -f, -h, -v, -a, or combined like -fa
+      for (const ch of arg.slice(1)) {
+        const long = FLAG_ALIASES[ch];
+        if (long) flags[long] = true;
+        else flags[ch] = true;
+      }
     } else {
       positional.push(arg);
     }
@@ -16,6 +26,35 @@ function parseArgs(args) {
   return { flags, positional };
 }
 
+// Known commands for fuzzy matching on typos
+const KNOWN_COMMANDS = ['stack', 'skills', 'persistent'];
+
+function suggestCommand(input) {
+  const lower = input.toLowerCase();
+  let best = null, bestDist = 3; // threshold: edit distance ≤ 2
+  for (const cmd of KNOWN_COMMANDS) {
+    if (cmd.startsWith(lower) || lower.startsWith(cmd)) return cmd;
+    const d = editDistance(lower, cmd);
+    if (d < bestDist) { bestDist = d; best = cmd; }
+  }
+  return best;
+}
+
+function editDistance(a, b) {
+  const m = a.length, n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++)
+    for (let j = 1; j <= n; j++)
+      dp[i][j] = Math.min(
+        dp[i - 1][j] + 1,
+        dp[i][j - 1] + 1,
+        dp[i - 1][j - 1] + (a[i - 1] !== b[j - 1] ? 1 : 0),
+      );
+  return dp[m][n];
+}
+
 function showHelp() {
   printHeader();
   console.log(`  ${bold('Usage:')} serpentstack <command> [options]
@@ -32,10 +71,10 @@ function showHelp() {
     ${cyan('persistent')} --reconfigure      Re-run setup (change models, enable/disable)
 
   ${bold('Options:')}
-    --force                       Overwrite existing files
-    --all                         Include new files in updates (skills update)
-    --version                     Show version
-    --help                        Show this help
+    -f, --force                   Overwrite existing files
+    -a, --all                     Include new files in updates (skills update)
+    -v, --version                 Show version
+    -h, --help                    Show this help
 
   ${dim('Examples:')}
     ${dim('$')} serpentstack stack new my-saas-app
@@ -95,7 +134,12 @@ async function main() {
     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`);
+    const suggestion = suggestCommand(noun);
+    if (suggestion) {
+      console.log(`\n  Did you mean ${bold(suggestion)}? Run ${bold(`serpentstack ${suggestion}`)} or ${bold('serpentstack --help')}.\n`);
+    } else {
+      console.log(`\n  Run ${bold('serpentstack --help')} to see available commands.\n`);
+    }
     process.exit(1);
   }
 }

package/lib/commands/persistent.js

@@ -3,7 +3,7 @@ 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 { info, success, warn, error, bold, dim, green, cyan, yellow, red, printBox, printHeader } from '../utils/ui.js';
 import {
   parseAgentMd,
   discoverAgents,
@@ -22,6 +22,9 @@ import {
   getEffectiveModel,
   isAgentEnabled,
 } from '../utils/config.js';
+import { detectModels, modelShortName } from '../utils/models.js';
+
+// ─── Helpers ────────────────────────────────────────────────
 
 function which(cmd) {
   return new Promise((resolve) => {
@@ -29,74 +32,138 @@ function which(cmd) {
   });
 }
 
-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 ask(rl, label, defaultValue) {
+  const hint = defaultValue ? ` ${dim(`[${defaultValue}]`)}` : '';
+  const answer = await rl.question(`  ${green('?')} ${bold(label)}${hint}: `);
+  return answer.trim() || defaultValue || '';
 }
 
-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 || '';
+async function askYesNo(rl, label, defaultYes = true) {
+  const hint = defaultYes ? dim('[Y/n]') : dim('[y/N]');
+  const answer = await rl.question(`  ${green('?')} ${label} ${hint} `);
+  const val = answer.trim().toLowerCase();
+  if (defaultYes) return val !== 'n' && val !== 'no';
+  return val === 'y' || val === 'yes';
+}
+
+// ─── Model Picker ───────────────────────────────────────────
+
+async function pickModel(rl, agentName, currentModel, available) {
+  const choices = [];
+
+  // Local models first (free, fast, recommended)
+  if (available.local.length > 0) {
+    console.log(`    ${dim('\u2500\u2500 Local models (free, no API key needed) \u2500\u2500')}`);
+    for (const m of available.local) {
+      const isCurrent = m.id === currentModel;
+      const idx = choices.length;
+      choices.push(m);
+      const marker = isCurrent ? green('>') : ' ';
+      const num = dim(`${idx + 1}.`);
+      const label = isCurrent ? bold(m.name) : m.name;
+      const params = m.params ? dim(` ${m.params}`) : '';
+      const size = m.size ? dim(` (${m.size})`) : '';
+      const tag = isCurrent ? green(' \u2190 current') : '';
+      console.log(`  ${marker} ${num} ${label}${params}${size}${tag}`);
+    }
+  }
+
+  // Cloud models (require API key, cost money)
+  if (available.cloud.length > 0) {
+    const apiNote = available.hasApiKey ? dim('API key configured') : yellow('requires API key');
+    console.log(`    ${dim('\u2500\u2500 Cloud models')} (${apiNote}) ${dim('\u2500\u2500')}`);
+    for (const m of available.cloud) {
+      const isCurrent = m.id === currentModel;
+      const idx = choices.length;
+      choices.push(m);
+      const marker = isCurrent ? green('>') : ' ';
+      const num = dim(`${idx + 1}.`);
+      const label = isCurrent ? bold(m.name) : m.name;
+      const provider = m.provider ? dim(` (${m.provider})`) : '';
+      const tag = isCurrent ? green(' \u2190 current') : '';
+      console.log(`  ${marker} ${num} ${label}${provider}${tag}`);
+    }
+  }
+
+  // If current model isn't in either list, add it
+  if (!choices.some(c => c.id === currentModel)) {
+    choices.unshift({ id: currentModel, name: modelShortName(currentModel), tier: 'custom' });
+    // Re-render isn't needed since we'll just note it
+    console.log(`    ${dim(`Current: ${modelShortName(currentModel)} (not in detected models)`)}`);
+  }
+
+  const currentIdx = choices.findIndex(c => c.id === currentModel);
+  const defaultNum = currentIdx >= 0 ? currentIdx + 1 : 1;
+
+  const answer = await rl.question(`    ${dim(`Enter 1-${choices.length}`)} ${dim(`[${defaultNum}]`)}: `);
+  const idx = parseInt(answer.trim(), 10) - 1;
+
+  const selected = (idx >= 0 && idx < choices.length) ? choices[idx] : choices[Math.max(0, currentIdx)];
+
+  // Warn about cloud model costs
+  if (selected.tier === 'cloud' && available.local.length > 0) {
+    warn(`Cloud models cost tokens per heartbeat cycle. Consider a local model for persistent agents.`);
+  }
+  if (selected.tier === 'cloud' && !available.hasApiKey) {
+    warn(`No API key detected. Run ${bold('openclaw configure')} to set up authentication.`);
+  }
+
+  return selected.id;
 }
 
 // ─── 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 || '';
+  const safeCwd = cwd.replace(/'/g, "'\\''").replace(/"/g, '\\"');
+  const safeCmd = command.replace(/"/g, '\\"');
 
   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
-      `;
+      const script = `tell application "iTerm"
+  tell current window
+    create tab with default profile
+    tell current session
+      set name to "${title}"
+      write text "cd '${safeCwd}' && ${safeCmd}"
+    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';
+      return 'iTerm';
     }
-  } else if (platform === 'linux') {
-    // Try common Linux terminal emulators
+    const script = `tell application "Terminal"
+  activate
+  do script "cd '${safeCwd}' && ${safeCmd}"
+end tell`;
+    spawn('osascript', ['-e', script], { stdio: 'ignore', detached: true }).unref();
+    return 'Terminal';
+  }
+
+  if (platform === 'linux') {
+    const shellCmd = `cd '${safeCwd}' && ${command}; exec bash`;
     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`]],
+      ['gnome-terminal', ['--title', title, '--', 'bash', '-c', shellCmd]],
+      ['kitty', ['--title', title, 'bash', '-c', shellCmd]],
+      ['alacritty', ['--title', title, '-e', 'bash', '-c', shellCmd]],
+      ['wezterm', ['start', '--', 'bash', '-c', shellCmd]],
+      ['konsole', ['--new-tab', '-e', 'bash', '-c', shellCmd]],
+      ['xterm', ['-title', title, '-e', 'bash', '-c', shellCmd]],
     ];
-
     for (const [bin, args] of terminals) {
       try {
-        spawn(bin, args, { stdio: 'ignore', detached: true }).unref();
-        return bin;
+        const child = spawn(bin, args, { stdio: 'ignore', detached: true });
+        child.unref();
+        // Verify it didn't immediately fail
+        const alive = child.pid && !child.killed;
+        if (alive) return bin;
       } catch { continue; }
     }
-  } else if (platform === 'win32') {
-    spawn('cmd.exe', ['/c', 'start', 'cmd', '/k', `cd /d ${cwd} && ${command}`], {
+  }
+
+  if (platform === 'win32') {
+    spawn('cmd.exe', ['/c', 'start', `"${title}"`, 'cmd', '/k', `cd /d "${cwd}" && ${command}`], {
       stdio: 'ignore', detached: true,
     }).unref();
     return 'cmd';
@@ -105,10 +172,6 @@ function openInTerminal(title, command, cwd) {
   return null;
 }
 
-function escapeShell(str) {
-  return str.replace(/'/g, "'\\''");
-}
-
 // ─── Stop Flow ──────────────────────────────────────────────
 
 function stopAllAgents(projectDir) {
@@ -118,156 +181,33 @@ function stopAllAgents(projectDir) {
   if (running.length === 0) {
     info('No agents are currently running.');
     console.log();
-    return;
+    return 0;
   }
 
-  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})`)}`);
+      success(`Stopped ${bold(name)} ${dim(`(PID ${pid})`)}`);
       stopped++;
     } catch (err) {
       if (err.code === 'ESRCH') {
         removePid(projectDir, name);
-        success(`${bold(name)} already stopped`);
-        stopped++;
+        // Don't count already-dead processes as "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')}`);
+  if (stopped > 0) {
     console.log();
-    return false;
+    success(`${stopped} agent(s) stopped`);
   }
-
-  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;
+  return stopped;
 }
 
 // ─── Agent Status ───────────────────────────────────────────
@@ -279,7 +219,7 @@ function getAgentStatus(projectDir, name, config) {
   return { status: 'stopped', pid: null };
 }
 
-function printAgentStatus(name, agentMd, config, statusInfo) {
+function printAgentLine(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);
@@ -300,144 +240,254 @@ export async function persistent({ stop = false, reconfigure = false } = {}) {
 
   printHeader();
 
-  // --stop flag
+  // ── Stop ──
   if (stop) {
     stopAllAgents(projectDir);
     return;
   }
 
-  // Check workspace exists
+  // ── Preflight checks ──
   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);
   }
 
+  // Check OpenClaw early — don't waste time configuring if it's missing
+  const hasOpenClaw = await which('openclaw');
+  if (!hasOpenClaw) {
+    warn('OpenClaw is not installed.');
+    console.log();
+    console.log(`  ${dim('OpenClaw is the persistent agent runtime.')}`);
+    console.log(`  ${dim('Install it first, then re-run this command:')}`);
+    console.log();
+    console.log(`  ${dim('$')} ${bold('npm install -g openclaw@latest')}`);
+    console.log(`  ${dim('$')} ${bold('serpentstack persistent')}`);
+    console.log();
+    process.exit(1);
+  }
+
   cleanStalePids(projectDir);
 
-  // Parse all AGENT.md files
+  // Parse agent definitions
   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}`);
+      warn(`Skipping ${bold(agent.name)}: ${err.message}`);
     }
   }
-
   if (parsed.length === 0) {
-    error('No valid agents found. Check your AGENT.md files.');
+    error('No valid AGENT.md files found.');
     console.log();
     process.exit(1);
   }
 
-  // Load or create config
+  // Load 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')}`);
+  // Detect models in background while we show status
+  const modelsPromise = detectModels();
 
-    config.project = await configureProject(projectDir, config);
+  // ── If configured, show status dashboard ──
+  if (!needsSetup) {
+    console.log(`  ${bold(config.project.name)} ${dim(`\u2014 ${config.project.framework}`)}`);
+    console.log(`  ${dim(`Dev: ${config.project.devCmd} \u2022 Test: ${config.project.testCmd}`)}`);
     console.log();
 
-    // Configure agents
-    console.log(`  ${bold('Agent Configuration')}`);
+    for (const { name, agentMd } of parsed) {
+      const statusInfo = getAgentStatus(projectDir, name, config);
+      printAgentLine(name, agentMd, config, statusInfo);
+    }
     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'}`)}`);
+    // Determine what to do
+    const enabledAgents = parsed.filter(a => isAgentEnabled(a.name, config));
+    const runningNames = new Set(listPids(projectDir).map(p => p.name));
+    const startable = enabledAgents.filter(a => !runningNames.has(a.name));
 
-        const agentConfig = await configureAgent(rl, name, agentMd, config.agents?.[name]);
-        config.agents[name] = agentConfig;
+    if (startable.length === 0 && runningNames.size > 0) {
+      info('All enabled agents are running.');
+      console.log(`  ${dim('Run')} ${bold('serpentstack persistent --stop')} ${dim('to stop them.')}`);
+      console.log(`  ${dim('Run')} ${bold('serpentstack persistent --reconfigure')} ${dim('to change settings.')}`);
+      console.log();
+      return;
+    }
 
-        const status = agentConfig.enabled ? green('enabled') : dim('disabled');
-        console.log(`    ${dim('\u2192')} ${status}${agentConfig.enabled ? `, ${dim(modelShortName(agentConfig.model))}` : ''}`);
-        console.log();
-      }
-    } finally {
-      rl.close();
+    if (startable.length === 0) {
+      info('No agents are enabled.');
+      console.log(`  ${dim('Run')} ${bold('serpentstack persistent --reconfigure')} ${dim('to enable agents.')}`);
+      console.log();
+      return;
     }
 
-    writeConfig(projectDir, config);
-    success(`Saved ${bold('.openclaw/config.json')}`);
+    // Start startable agents
+    await launchAgents(projectDir, startable, config, soulPath);
+    return;
+  }
+
+  // ── First-time setup / reconfigure ──
+  if (reconfigure) {
+    info('Reconfiguring...');
     console.log();
   }
 
-  // Show current status
-  console.log(`  ${bold('Agents')}`);
-  console.log();
+  const rl = createInterface({ input: stdin, output: stdout });
+  let configDirty = false;
 
-  for (const { name, agentMd } of parsed) {
-    const statusInfo = getAgentStatus(projectDir, name, config);
-    printAgentStatus(name, agentMd, config, statusInfo);
-  }
-  console.log();
+  try {
+    // ── Project configuration ──
+    const templateDefaults = detectTemplateDefaults(projectDir);
+    const existing = config.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 || '',
+    };
 
-  // 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 (templateDefaults && !existing.name) {
+      info('Detected SerpentStack template \u2014 defaults pre-filled');
+      console.log();
+    }
 
-  if (startableAgents.length === 0 && runningAgents.length > 0) {
-    info('All enabled agents are already running.');
+    console.log(`  ${bold('Project')}`);
+    console.log(`  ${dim('Press Enter to keep current values.')}`);
     console.log();
 
-    const doStop = await confirm('Stop all agents?');
-    if (doStop) {
+    config.project = {
+      name: await ask(rl, 'Project name', defaults.name),
+      language: await ask(rl, 'Primary language', defaults.language),
+      framework: await ask(rl, 'Framework', defaults.framework),
+      devCmd: await ask(rl, 'Dev server command', defaults.devCmd),
+      testCmd: await ask(rl, 'Test command', defaults.testCmd),
+      conventions: await ask(rl, 'Key conventions', defaults.conventions),
+    };
+    configDirty = true;
+
+    // Update SOUL.md
+    if (existsSync(soulPath)) {
+      let soul = readFileSync(soulPath, 'utf8');
+      const ctx = [
+        `# ${config.project.name} \u2014 Persistent Development Agents`,
+        '',
+        `**Project:** ${config.project.name}`,
+        `**Language:** ${config.project.language}`,
+        `**Framework:** ${config.project.framework}`,
+        `**Dev server:** \`${config.project.devCmd}\``,
+        `**Tests:** \`${config.project.testCmd}\``,
+        `**Conventions:** ${config.project.conventions}`,
+        '', '---', '',
+      ].join('\n');
+      const dashIdx = soul.indexOf('---');
+      soul = dashIdx !== -1 ? ctx + soul.slice(dashIdx + 3).trimStart() : ctx + soul;
+      writeFileSync(soulPath, soul, 'utf8');
+    }
+    console.log();
+    success(`Updated ${bold('.openclaw/SOUL.md')}`);
+    console.log();
+
+    // ── Agent configuration ──
+    const available = await modelsPromise;
+
+    if (available.local.length > 0) {
+      info(`${available.local.length} local model(s) detected via Ollama`);
+    } else {
+      warn('No local models found. Install Ollama and pull a model for free persistent agents:');
+      console.log(`  ${dim('$')} ${bold('ollama pull llama3.2')}`);
+    }
+    if (available.hasApiKey) {
+      info('API key configured for cloud models');
+    }
+    console.log();
+
+    console.log(`  ${bold('Agents')}`);
+    console.log(`  ${dim('Enable/disable each agent and choose its model.')}`);
+    console.log();
+
+    for (const { name, agentMd } of parsed) {
+      const existingAgent = config.agents?.[name];
+      const currentEnabled = existingAgent?.enabled !== false;
+      const currentModel = existingAgent?.model || agentMd.meta.model || 'anthropic/claude-haiku-4-20250414';
+      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 enabled = await askYesNo(rl, `Enable ${bold(name)}?`, currentEnabled);
+
+      let model = currentModel;
+      if (enabled) {
+        console.log();
+        model = await pickModel(rl, name, currentModel, available);
+      }
+
+      config.agents[name] = { enabled, model };
+
+      const status = enabled ? green('\u2713 enabled') : dim('\u2717 disabled');
+      const modelLabel = enabled ? `, ${modelShortName(model)}` : '';
+      console.log(`    ${status}${modelLabel}`);
+      console.log();
+    }
+
+    configDirty = true;
+  } finally {
+    rl.close();
+    // Only save if we completed configuration
+    if (configDirty) {
+      writeConfig(projectDir, config);
+      success(`Saved ${bold('.openclaw/config.json')}`);
       console.log();
-      stopAllAgents(projectDir);
     }
-    return;
   }
 
-  if (startableAgents.length === 0) {
-    info('No agents are enabled. Run with --reconfigure to enable agents.');
+  // Show status and launch
+  for (const { name, agentMd } of parsed) {
+    const statusInfo = getAgentStatus(projectDir, name, config);
+    printAgentLine(name, agentMd, config, statusInfo);
+  }
+  console.log();
+
+  const enabledAgents = parsed.filter(a => isAgentEnabled(a.name, config));
+  if (enabledAgents.length === 0) {
+    info('No agents enabled. Run with --reconfigure to enable agents.');
     console.log();
     return;
   }
 
-  // Let user pick which agents to start
+  await launchAgents(projectDir, enabledAgents, config, soulPath);
+}
+
+// ─── Launch Flow ────────────────────────────────────────────
+
+async function launchAgents(projectDir, agentsToStart, config, soulPath) {
   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();
+    console.log(`  ${dim('Select agents to launch:')}`);
+    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);
-        }
-      }
+    for (const agent of agentsToStart) {
+      const model = getEffectiveModel(agent.name, agent.agentMd.meta, config);
+      const yes = await askYesNo(rl, `Start ${bold(agent.name)} ${dim(`(${modelShortName(model)})`)}?`, true);
+      if (yes) toStart.push(agent);
     }
   } finally {
     rl.close();
@@ -450,16 +500,8 @@ export async function persistent({ stop = false, reconfigure = false } = {}) {
     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;
 
@@ -475,24 +517,19 @@ export async function persistent({ stop = false, reconfigure = false } = {}) {
       const absWorkspace = resolve(workspacePath);
       const absProject = resolve(projectDir);
 
-      // Build the openclaw command
-      const openclawCmd = `OPENCLAW_STATE_DIR="${join(absWorkspace, '.state')}" openclaw start --workspace "${absWorkspace}"`;
+      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,
-      );
+      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)})`)}`);
+        // For terminal-spawned agents, record workspace path so we can track it
+        // The terminal process will create its own PID — we record ours as a marker
+        writePid(projectDir, name, -1); // -1 = terminal-managed
+        success(`${bold(name)} opened in ${method} ${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`);
+        // Fallback: background process
+        warn(`No terminal detected \u2014 starting ${bold(name)} in background`);
         const child = spawn('openclaw', ['start', '--workspace', absWorkspace], {
           stdio: 'ignore',
           detached: true,
@@ -501,7 +538,7 @@ export async function persistent({ stop = false, reconfigure = false } = {}) {
         });
         child.unref();
         writePid(projectDir, name, child.pid);
-        success(`${bold(name)} started in background ${dim(`PID ${child.pid}`)}`);
+        success(`${bold(name)} started ${dim(`PID ${child.pid}`)}`);
         started++;
       }
     } catch (err) {
@@ -511,18 +548,12 @@ export async function persistent({ stop = false, reconfigure = false } = {}) {
 
   console.log();
   if (started > 0) {
-    success(`${green(String(started))} agent(s) launched`);
+    success(`${started} agent(s) launched`);
     console.log();
     printBox('Manage agents', [
-      `${dim('$')} ${bold('serpentstack persistent')}                ${dim('# view status + start agents')}`,
+      `${dim('$')} ${bold('serpentstack persistent')}                ${dim('# 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

@@ -1,6 +1,9 @@
 import { join } from 'node:path';
+import { existsSync } from 'node:fs';
 import { downloadFile } from '../utils/github.js';
 import { safeWrite } from '../utils/fs-helpers.js';
+import { readConfig, writeConfig, detectTemplateDefaults, defaultAgentConfig } from '../utils/config.js';
+import { parseAgentMd, discoverAgents } from '../utils/agent-utils.js';
 import { info, success, warn, error, spinner, bold, dim, green, printBox, printPrompt, printHeader, fileStatus } from '../utils/ui.js';
 
 const SKILLS_FILES = [
@@ -27,10 +30,10 @@ export async function skillsInit({ force = false } = {}) {
   printHeader();
 
   // Step 1: Download files
-  console.log(`  ${bold('Step 1/2')} ${dim('\u2014 Downloading skills + persistent agent configs')}`);
+  console.log(`  ${bold('Downloading')} ${dim('skills + persistent agent configs')}`);
   console.log();
 
-  const results = { created: 0, skipped: 0, overwritten: 0, failed: 0 };
+  const results = { created: 0, skipped: 0, overwritten: 0, unchanged: 0, failed: 0 };
   const logs = [];
   const spin = spinner('Fetching from GitHub...');
 
@@ -66,6 +69,7 @@ export async function skillsInit({ force = false } = {}) {
   const parts = [];
   if (results.created > 0) parts.push(green(`${results.created} created`));
   if (results.overwritten > 0) parts.push(`${results.overwritten} updated`);
+  if (results.unchanged > 0) parts.push(`${results.unchanged} up to date`);
   if (results.skipped > 0) parts.push(`${results.skipped} skipped`);
   if (results.failed > 0) parts.push(`${results.failed} failed`);
   console.log(`  ${parts.join(dim(' \u2022 '))}`);
@@ -76,9 +80,40 @@ export async function skillsInit({ force = false } = {}) {
     return;
   }
 
-  // Step 2: What to do next
+  // Generate default config.json if it doesn't exist
+  const projectDir = process.cwd();
+  if (!readConfig(projectDir)) {
+    const templateDefaults = detectTemplateDefaults(projectDir) || {};
+    const config = {
+      project: {
+        name: templateDefaults.name || '',
+        language: templateDefaults.language || '',
+        framework: templateDefaults.framework || '',
+        devCmd: templateDefaults.devCmd || '',
+        testCmd: templateDefaults.testCmd || '',
+        conventions: templateDefaults.conventions || '',
+      },
+      agents: {},
+    };
+
+    // Populate agent defaults from downloaded AGENT.md files
+    const agents = discoverAgents(projectDir);
+    for (const agent of agents) {
+      try {
+        const agentMd = parseAgentMd(agent.agentMdPath);
+        config.agents[agent.name] = defaultAgentConfig(agentMd.meta);
+      } catch { /* skip invalid agents */ }
+    }
+
+    writeConfig(projectDir, config);
+    console.log(`  ${fileStatus('.openclaw/config.json', 'created')}`);
+    results.created++;
+    console.log();
+  }
+
+  // Next steps
   console.log();
-  console.log(`  ${bold('Step 2/2')} ${dim('\u2014 Generate project-specific skills')}`);
+  console.log(`  ${bold('Next')} ${dim('\u2014 Generate project-specific skills')}`);
   console.log();
   console.log(`  ${dim('Open your IDE agent (Claude Code, Cursor, Copilot, etc.)')}`);
   console.log(`  ${dim('and paste the prompt below. The agent will read your codebase,')}`);

package/lib/commands/stack-new.js

@@ -26,6 +26,22 @@ function checkCommand(cmd) {
   });
 }
 
+function getCommandVersion(cmd, args = ['--version']) {
+  return new Promise((resolve) => {
+    execFile(cmd, args, { timeout: 5000 }, (err, stdout) => {
+      if (err) resolve(null);
+      else resolve(stdout.trim());
+    });
+  });
+}
+
+function parseVersion(versionStr) {
+  if (!versionStr) return null;
+  const match = versionStr.match(/(\d+)\.(\d+)/);
+  if (!match) return null;
+  return { major: parseInt(match[1]), minor: parseInt(match[2]) };
+}
+
 export async function stackNew(name) {
   const nameError = validateName(name);
   if (nameError) {
@@ -49,20 +65,38 @@ export async function stackNew(name) {
 
   const checks = [
     { cmd: 'git', label: 'git', url: 'https://git-scm.com/downloads' },
-    { cmd: 'python3', label: 'Python 3.12+', url: 'https://python.org/downloads' },
-    { cmd: 'node', label: 'Node 22+', url: 'https://nodejs.org' },
+    { cmd: 'python3', label: 'Python 3.12+', url: 'https://python.org/downloads', minMajor: 3, minMinor: 12 },
+    { cmd: 'node', label: 'Node 22+', url: 'https://nodejs.org', minMajor: 22, minMinor: 0 },
     { cmd: 'docker', label: 'Docker', url: 'https://docker.com/get-started' },
     { cmd: 'uv', label: 'uv (Python package manager)', url: 'https://docs.astral.sh/uv' },
   ];
 
-  let missing = [];
-  for (const { cmd, label, url } of checks) {
+  // Run all checks in parallel
+  const results = await Promise.all(checks.map(async ({ cmd, label, url, minMajor, minMinor }) => {
     const found = await checkCommand(cmd);
-    if (found) {
-      console.log(`  ${green('\u2713')} ${label}`);
+    if (!found) return { label, url, found: false };
+
+    // Version check if required
+    if (minMajor != null) {
+      const vStr = await getCommandVersion(cmd);
+      const ver = parseVersion(vStr);
+      if (ver && (ver.major < minMajor || (ver.major === minMajor && ver.minor < minMinor))) {
+        return { label, url, found: true, versionOk: false, version: vStr };
+      }
+    }
+    return { label, found: true, versionOk: true };
+  }));
+
+  let missing = [];
+  for (const r of results) {
+    if (!r.found) {
+      console.log(`  ${dim('\u2022')} ${dim(r.label)} ${dim(`\u2014 install: ${r.url}`)}`);
+      missing.push(r.label);
+    } else if (r.versionOk === false) {
+      console.log(`  ${yellow('\u25B3')} ${r.label} ${dim(`\u2014 found ${r.version}, need newer version`)}`);
+      missing.push(r.label);
     } else {
-      console.log(`  ${dim('\u2022')} ${dim(label)} ${dim(`\u2014 install: ${url}`)}`);
-      missing.push(label);
+      console.log(`  ${green('\u2713')} ${r.label}`);
     }
   }
   console.log();
@@ -85,7 +119,8 @@ export async function stackNew(name) {
   const spin = spinner(`Downloading SerpentStack template...`);
   try {
     await cloneRepo(dest);
-    spin.stop(success(`Template cloned into ${green(name)}/`));
+    spin.stop();
+    success(`Template cloned into ${green(name)}/`);
   } catch (err) {
     spin.stop();
     error(err.message);

package/lib/utils/config.js

@@ -22,7 +22,10 @@ export function readConfig(projectDir) {
   if (!existsSync(configPath)) return null;
   try {
     return JSON.parse(readFileSync(configPath, 'utf8'));
-  } catch {
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      console.error(`  \x1b[33m\u25B3\x1b[0m .openclaw/config.json has invalid JSON — ignoring. Fix it or delete it to regenerate.`);
+    }
     return null;
   }
 }
@@ -46,8 +49,8 @@ export function detectTemplateDefaults(projectDir) {
 
   try {
     const content = readFileSync(makefile, 'utf8');
-    // SerpentStack Makefile has these distinctive targets
-    if (!content.includes('make verify') && !content.includes('.PHONY:') ) return null;
+    // SerpentStack Makefile: must have 'make verify' AND either 'uv run' or 'uvicorn'
+    if (!content.includes('make verify')) return null;
     if (!content.includes('uv run') && !content.includes('uvicorn')) return null;
 
     // It's a SerpentStack template project — return smart defaults

package/lib/utils/fs-helpers.js

@@ -19,7 +19,7 @@ export function safeWrite(destPath, content, { force = false } = {}) {
     // Don't overwrite if content is identical
     try {
       const existing = readFileSync(destPath, 'utf8');
-      if (existing === content) return 'skipped';
+      if (existing === content) return 'unchanged';
     } catch { /* proceed with overwrite */ }
 
     writeFileSync(destPath, content, 'utf8');

package/lib/utils/models.js

@@ -0,0 +1,156 @@
+import { execFile } from 'node:child_process';
+
+/**
+ * Detect all available models: local (Ollama) and cloud (via OpenClaw auth).
+ * Local models are preferred for persistent agents — they're free and fast.
+ * Cloud models require API keys and cost money per token.
+ *
+ * Returns { local: [...], cloud: [...], hasApiKey: bool }
+ */
+export async function detectModels() {
+  const [ollamaModels, openclawInfo] = await Promise.all([
+    detectOllamaModels(),
+    detectOpenClawAuth(),
+  ]);
+
+  return {
+    local: ollamaModels,
+    cloud: openclawInfo.models,
+    hasApiKey: openclawInfo.hasApiKey,
+  };
+}
+
+/**
+ * Detect locally installed Ollama models with parameter counts.
+ * Parses `ollama list` output.
+ */
+async function detectOllamaModels() {
+  try {
+    const output = await execAsync('ollama', ['list']);
+    const lines = output.trim().split('\n');
+    if (lines.length < 2) return []; // header only
+
+    // Parse header to find column positions
+    const header = lines[0];
+    const nameEnd = header.indexOf('ID');
+    const sizeStart = header.indexOf('SIZE');
+
+    return lines.slice(1).map(line => {
+      if (!line.trim()) return null;
+
+      const name = line.slice(0, nameEnd).trim();
+      if (!name) return null;
+
+      // Extract size (e.g., "4.7 GB", "1.3 GB")
+      const sizeStr = sizeStart >= 0 ? line.slice(sizeStart).trim().split(/\s{2,}/)[0] : '';
+
+      // Estimate parameter count from model name (e.g., "llama3.2:3b", "qwen2.5-coder:7b")
+      const paramMatch = name.match(/[:\-](\d+\.?\d*)[bB]/);
+      const params = paramMatch ? paramMatch[1] + 'B' : guessParams(name, sizeStr);
+
+      const shortName = name.replace(':latest', '');
+
+      return {
+        id: `ollama/${shortName}`,
+        name: shortName,
+        params,
+        size: sizeStr,
+        tier: 'local',
+      };
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Guess parameter count from file size if not in the name.
+ * Rough heuristic: ~0.5GB per billion parameters for Q4 quantization.
+ */
+function guessParams(name, sizeStr) {
+  const gbMatch = sizeStr.match(/([\d.]+)\s*GB/i);
+  if (gbMatch) {
+    const gb = parseFloat(gbMatch[1]);
+    const billions = Math.round(gb * 2); // Q4 ≈ 0.5GB/B
+    if (billions > 0) return `~${billions}B`;
+  }
+  return '';
+}
+
+/**
+ * Check OpenClaw for configured models and API key status.
+ */
+async function detectOpenClawAuth() {
+  const result = { models: [], hasApiKey: false };
+
+  try {
+    // Check if any API key is configured via openclaw models status
+    const status = await execAsync('openclaw', ['models', 'status']);
+
+    // Look for "api_key" or "configured" in the output
+    if (status.includes('api_key') || status.includes('configured')) {
+      result.hasApiKey = true;
+    }
+
+    // Get the model catalog for cloud options
+    const list = await execAsync('openclaw', ['models', 'list', '--json']);
+    try {
+      const models = JSON.parse(list);
+      if (Array.isArray(models)) {
+        result.models = models
+          .filter(m => m.available && !m.local)
+          .map(m => ({
+            id: m.key || m.name,
+            name: modelShortName(m.key || m.name),
+            provider: (m.key || '').split('/')[0] || 'unknown',
+            tier: 'cloud',
+          }));
+      }
+    } catch {
+      // Fall back to text parsing
+      const text = await execAsync('openclaw', ['models', 'list']);
+      const lines = text.trim().split('\n').filter(l => l.trim() && !l.startsWith('Model'));
+      result.models = lines.map(l => {
+        const id = l.trim().split(/\s+/)[0];
+        if (!id || id.length < 3) return null;
+        return { id, name: modelShortName(id), provider: id.split('/')[0], tier: 'cloud' };
+      }).filter(Boolean);
+    }
+  } catch {
+    // OpenClaw not installed or no models configured — use defaults
+    result.models = [
+      { id: 'anthropic/claude-haiku-4-20250414', name: 'Haiku', provider: 'anthropic', tier: 'cloud' },
+      { id: 'anthropic/claude-sonnet-4-20250514', name: 'Sonnet', provider: 'anthropic', tier: 'cloud' },
+    ];
+  }
+
+  return result;
+}
+
+/**
+ * Short display name for a model ID.
+ */
+export function modelShortName(model) {
+  if (!model) return 'unknown';
+  // Anthropic models
+  if (model.startsWith('anthropic/')) {
+    if (model.includes('haiku')) return 'Haiku';
+    if (model.includes('sonnet')) return 'Sonnet';
+    if (model.includes('opus')) return 'Opus';
+    return model.slice('anthropic/'.length);
+  }
+  // Ollama models
+  if (model.startsWith('ollama/')) return model.slice('ollama/'.length);
+  // Other: strip provider prefix
+  if (model.includes('/')) return model.split('/').pop();
+  return model;
+}
+
+function execAsync(cmd, args) {
+  return new Promise((resolve, reject) => {
+    execFile(cmd, args, { timeout: 5000 }, (err, stdout) => {
+      if (err) reject(err);
+      else resolve(stdout);
+    });
+  });
+}

package/lib/utils/ui.js

@@ -17,10 +17,10 @@ const MAGENTA = c(35);
 const CYAN = c(36);
 const BG_DIM = c(100);
 
-export const info = (msg) => console.log(`${CYAN}\u2022${RESET} ${msg}`);
-export const success = (msg) => console.log(`${GREEN}\u2713${RESET} ${msg}`);
-export const warn = (msg) => console.log(`${YELLOW}\u25B3${RESET} ${msg}`);
-export const error = (msg) => console.error(`${RED}\u2717${RESET} ${msg}`);
+export const info = (msg) => console.log(`  ${CYAN}\u2022${RESET} ${msg}`);
+export const success = (msg) => console.log(`  ${GREEN}\u2713${RESET} ${msg}`);
+export const warn = (msg) => console.log(`  ${YELLOW}\u25B3${RESET} ${msg}`);
+export const error = (msg) => console.error(`  ${RED}\u2717${RESET} ${msg}`);
 export const dim = (msg) => `${DIM}${msg}${RESET}`;
 export const bold = (msg) => `${BOLD}${msg}${RESET}`;
 export const green = (msg) => `${GREEN}${msg}${RESET}`;
@@ -147,5 +147,5 @@ export function fileStatus(path, status, detail) {
 }
 
 function stripAnsi(str) {
-  return str.replace(/\x1b\[\d+m/g, '');
+  return str.replace(/\x1b\[[\d;]*m/g, '');
 }

package/package.json

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