serpentstack 0.2.4 → 0.2.6

package/lib/commands/persistent.js

@@ -0,0 +1,559 @@
+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, 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';
+import { detectModels, modelShortName } from '../utils/models.js';
+
+// ─── Helpers ────────────────────────────────────────────────
+
+function which(cmd) {
+  return new Promise((resolve) => {
+    execFile('which', [cmd], (err) => resolve(!err));
+  });
+}
+
+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 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 ──────────────────────────────────────
+
+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') {
+      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';
+    }
+    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', 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 {
+        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; }
+    }
+  }
+
+  if (platform === 'win32') {
+    spawn('cmd.exe', ['/c', 'start', `"${title}"`, 'cmd', '/k', `cd /d "${cwd}" && ${command}`], {
+      stdio: 'ignore', detached: true,
+    }).unref();
+    return 'cmd';
+  }
+
+  return null;
+}
+
+// ─── Stop Flow ──────────────────────────────────────────────
+
+function stopAllAgents(projectDir) {
+  cleanStalePids(projectDir);
+  const running = listPids(projectDir);
+
+  if (running.length === 0) {
+    info('No agents are currently running.');
+    console.log();
+    return 0;
+  }
+
+  let stopped = 0;
+  for (const { name, pid } of running) {
+    try {
+      process.kill(pid, 'SIGTERM');
+      removePid(projectDir, name);
+      cleanWorkspace(projectDir, name);
+      success(`Stopped ${bold(name)} ${dim(`(PID ${pid})`)}`);
+      stopped++;
+    } catch (err) {
+      if (err.code === 'ESRCH') {
+        removePid(projectDir, name);
+        // Don't count already-dead processes as "stopped"
+      } else {
+        error(`Failed to stop ${bold(name)}: ${err.message}`);
+      }
+    }
+  }
+
+  if (stopped > 0) {
+    console.log();
+    success(`${stopped} agent(s) stopped`);
+  }
+  console.log();
+  return stopped;
+}
+
+// ─── 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 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);
+
+  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 ──
+  if (stop) {
+    stopAllAgents(projectDir);
+    return;
+  }
+
+  // ── Preflight checks ──
+  const soulPath = join(projectDir, '.openclaw/SOUL.md');
+  if (!existsSync(soulPath)) {
+    error('No .openclaw/ workspace found.');
+    console.log(`  Run ${bold('serpentstack skills')} first to download the workspace files.`);
+    console.log();
+    process.exit(1);
+  }
+
+  const agents = discoverAgents(projectDir);
+  if (agents.length === 0) {
+    error('No agents found in .openclaw/agents/');
+    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 agent definitions
+  const parsed = [];
+  for (const agent of agents) {
+    try {
+      const agentMd = parseAgentMd(agent.agentMdPath);
+      parsed.push({ ...agent, agentMd });
+    } catch (err) {
+      warn(`Skipping ${bold(agent.name)}: ${err.message}`);
+    }
+  }
+  if (parsed.length === 0) {
+    error('No valid AGENT.md files found.');
+    console.log();
+    process.exit(1);
+  }
+
+  // Load config
+  let config = readConfig(projectDir) || { project: {}, agents: {} };
+  const needsSetup = !config.project?.name || reconfigure;
+
+  // Detect models in background while we show status
+  const modelsPromise = detectModels();
+
+  // ── 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();
+
+    for (const { name, agentMd } of parsed) {
+      const statusInfo = getAgentStatus(projectDir, name, config);
+      printAgentLine(name, agentMd, config, statusInfo);
+    }
+    console.log();
+
+    // 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));
+
+    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;
+    }
+
+    if (startable.length === 0) {
+      info('No agents are enabled.');
+      console.log(`  ${dim('Run')} ${bold('serpentstack persistent --reconfigure')} ${dim('to enable agents.')}`);
+      console.log();
+      return;
+    }
+
+    // Start startable agents
+    await launchAgents(projectDir, startable, config, soulPath);
+    return;
+  }
+
+  // ── First-time setup / reconfigure ──
+  if (reconfigure) {
+    info('Reconfiguring...');
+    console.log();
+  }
+
+  const rl = createInterface({ input: stdin, output: stdout });
+  let configDirty = false;
+
+  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 || '',
+    };
+
+    if (templateDefaults && !existing.name) {
+      info('Detected SerpentStack template \u2014 defaults pre-filled');
+      console.log();
+    }
+
+    console.log(`  ${bold('Project')}`);
+    console.log(`  ${dim('Press Enter to keep current values.')}`);
+    console.log();
+
+    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();
+    }
+  }
+
+  // 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;
+  }
+
+  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 {
+    console.log(`  ${dim('Select agents to launch:')}`);
+    console.log();
+
+    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();
+  }
+
+  if (toStart.length === 0) {
+    console.log();
+    info('No agents selected.');
+    console.log();
+    return;
+  }
+
+  console.log();
+
+  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);
+
+      const openclawCmd = `OPENCLAW_STATE_DIR='${join(absWorkspace, '.state')}' openclaw start --workspace '${absWorkspace}'`;
+
+      const method = openInTerminal(`SerpentStack: ${name}`, openclawCmd, absProject);
+
+      if (method) {
+        // 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: background process
+        warn(`No terminal detected \u2014 starting ${bold(name)} 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 ${dim(`PID ${child.pid}`)}`);
+        started++;
+      }
+    } catch (err) {
+      error(`${bold(name)}: ${err.message}`);
+    }
+  }
+
+  console.log();
+  if (started > 0) {
+    success(`${started} agent(s) launched`);
+    console.log();
+    printBox('Manage 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')}`,
+    ]);
+  }
+}

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,')}`);
@@ -87,20 +122,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 persistent agents too', [
-    `${dim('$')} ${bold('serpentstack skills persistent')}  ${dim('# guided setup + start')}`,
+    `${dim('$')} ${bold('serpentstack persistent')}  ${dim('# choose agents + launch')}`,
     '',
     `${dim('Background agents that watch your dev server, run tests,')}`,
-    `${dim('and keep your skills up to date. Each agent in .openclaw/agents/')}`,
-    `${dim('runs independently — add, remove, or customize them freely.')}`,
+    `${dim('and keep your skills up to date. Each opens in its own')}`,
+    `${dim('terminal window. Pick which to run and choose your models.')}`,
   ]);
 }