homunculus-code 0.1.0 → 0.3.0

package/ARCHITECTURE.md

@@ -0,0 +1,211 @@
+# Architecture: Goal-Tree-Driven Evolution
+
+This document explains the design philosophy behind Homunculus.
+
+## The Problem
+
+AI assistants are statically configured. You write rules, add skills, configure hooks — but the AI never improves on its own. Every improvement requires human effort:
+
+1. Notice something could be better
+2. Research the solution
+3. Implement it (skill, hook, rule, script)
+4. Test it manually
+5. Maintain it when things change
+
+This doesn't scale. As your system grows, maintenance becomes a full-time job.
+
+## The Solution: Goal Trees
+
+Instead of configuring individual behaviors, you define **what you want** in a tree of goals. The system figures out **how to achieve it** — and keeps improving the "how" over time.
+
+### Why a Tree?
+
+Goals are naturally hierarchical:
+
+```
+"Ship better software"
+├── "Write fewer bugs"
+│   ├── "Every change has tests"
+│   └── "Catch issues before merge"
+└── "Move faster"
+    ├── "Automate repetitive tasks"
+    └── "Debug faster"
+```
+
+A tree structure gives you:
+- **Decomposition** — Break big goals into measurable sub-goals
+- **Priority** — Unhealthy sub-goals bubble up to their parent
+- **Independence** — Each sub-goal can be implemented differently
+- **Replaceability** — Swap implementations without affecting goals
+
+### Goal Node Schema
+
+Every node in the tree follows the same schema:
+
+```yaml
+goal_name:
+  purpose: "Why this goal exists"           # Never changes
+  realized_by: path/to/implementation       # Changes as system evolves
+  metrics:
+    - name: metric_name
+      source: where to get the data
+      healthy: "what healthy looks like"    # Defines success
+  health_check:
+    command: "shell command"                # Machine-executable
+    expected: "human description"           # For readability
+  goals:
+    sub_goal_1: ...                         # Recursive
+    sub_goal_2: ...
+```
+
+### The `realized_by` Field
+
+This is the key innovation. It decouples **what** (the goal) from **how** (the implementation). The value can be:
+
+- A skill: `skills/tdd-workflow.md`
+- An agent: `agents/code-reviewer.md`
+- A hook: `hooks/pre-commit.sh`
+- A script: `scripts/deploy.sh`
+- A cron job: `launchd/nightly.plist`
+- An MCP server: `mcp-servers/github`
+- A rule: `rules/security.md`
+- A slash command: `commands/quality-gate.md`
+- Or anything else
+
+The evolution system can **replace** the implementation at any time, as long as the goal's health check still passes. This is what makes the system truly self-improving — it's not locked into any particular approach.
+
+## Evolution Pipeline
+
+### Layer 1: Observation → Instincts
+
+```
+Tool usage → observe.sh (hook) → observations.jsonl
+                                        │
+                         evaluate-session.js (SessionEnd)
+                                        │
+                                        ▼
+                              instincts/personal/*.md
+                              (confidence-scored patterns)
+```
+
+Instincts are small behavioral patterns with:
+- **Confidence scores** — increase with reinforcement, decay over time
+- **Half-life decay** — unused instincts fade (default: 90 days)
+- **Automatic archival** — `prune-instincts.js` archives low-value ones
+
+### Layer 2: Convergence → Skills
+
+```
+Related instincts (3+)  →  /evolve  →  evolved/skills/*.md
+                                              │
+                                    eval spec (scenarios)
+                                              │
+                                    /eval-skill → score
+                                              │
+                                    /improve-skill → iterate
+                                              │
+                                        100% pass rate
+```
+
+Skills are:
+- **Tested** — every skill has an eval spec with scenario tests
+- **Versioned** — changes tracked with semver
+- **Quality-gated** — must pass eval before adoption
+- **Regression-protected** — rollback if quality drops
+
+### Layer 3: Goal-Directed Evolution
+
+```
+architecture.yaml
+       │
+       ▼
+health_check.command → pass/fail per goal
+       │
+       ▼
+Unhealthy goals get priority
+       │
+       ▼
+Evolution engine focuses improvement
+on the weakest areas
+```
+
+The goal tree adds **direction** to evolution. Without it, the system learns whatever patterns happen to occur. With it, the system asks: "which goals are failing?" and focuses there.
+
+### Layer 4: Autonomous Operation (Nightly Agent)
+
+```
+launchd/cron → heartbeat.sh (scheduled)
+                    │
+    ┌───────────────┼───────────────┐
+    ▼               ▼               ▼
+Health Check    Evolve Pipeline   Research
+    │               │               │
+    ▼               ▼               ▼
+Identify weak   eval → improve    Scan for better
+goals            → prune          approaches
+    │               │               │
+    └───────────────┼───────────────┘
+                    ▼
+            Morning Report
+```
+
+The nightly agent closes the loop — no human intervention needed for routine evolution.
+
+### Layer 5: Meta-Evolution
+
+The evolution mechanism itself is measured and adjusted:
+
+| Metric | What it measures | Action if unhealthy |
+|--------|-----------------|-------------------|
+| `instinct_survival_rate` | % of instincts surviving 14 days | Raise extraction thresholds |
+| `skill_convergence` | Time from first instinct to skill | Adjust aggregation triggers |
+| `eval_discrimination` | % of scenarios that distinguish versions | Add harder boundary scenarios |
+
+This prevents the system from degenerating — if it's extracting too many low-quality instincts, it automatically becomes more selective.
+
+## Design Principles
+
+### 1. Goals Over Implementations
+
+Never optimize an implementation directly. Always ask: "which goal does this serve?" If there's no goal, the implementation shouldn't exist.
+
+### 2. Measure Everything
+
+If you can't measure it, you can't evolve it. Every goal should eventually have a `health_check` or `metrics` entry. Start with approximate metrics and refine them.
+
+### 3. Replaceable Everything
+
+No implementation is sacred. A skill can be replaced by a hook. A script can be replaced by an agent. The only constant is the goal tree.
+
+### 4. Safe Evolution
+
+- Eval specs prevent regression
+- Experiments run in isolated worktrees
+- Rollback if quality drops
+- Noise tolerance (5pp) prevents chasing statistical artifacts
+
+### 5. Progressive Complexity
+
+Start simple:
+1. Just the goal tree + observation hook
+2. Let instincts accumulate naturally
+3. Evolve first skill when you have enough instincts
+4. Add eval spec for quality control
+5. Set up nightly agent when you're ready for autonomy
+
+Don't try to build the full system on day one. Let it grow.
+
+## Comparison with Other Approaches
+
+| Approach | Optimizes | Direction | Quality Control | Autonomous |
+|----------|-----------|-----------|----------------|------------|
+| Manual rules | Individual behaviors | Human-directed | None | No |
+| Claude Memory | Fact recall | Usage-driven | None | No |
+| OpenClaw skills | Skill generation | Human-triggered | None | Partial |
+| **Homunculus** | **Goal achievement** | **Goal-tree-driven** | **Eval specs** | **Yes (nightly)** |
+
+## Further Reading
+
+- [README.md](README.md) — Quick start and overview
+- [docs/nightly-agent.md](docs/nightly-agent.md) — Setting up autonomous operation
+- [examples/reference/](examples/reference/) — Real-world system after 15 days

package/README.md

@@ -1,5 +1,6 @@
 # Homunculus for Claude Code
 
+[![npm version](https://img.shields.io/npm/v/homunculus-code)](https://www.npmjs.com/package/homunculus-code)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Claude Code](https://img.shields.io/badge/Claude%20Code-v2.1.70+-blue)](https://docs.anthropic.com/en/docs/claude-code)
 [![Node.js](https://img.shields.io/badge/Node.js-18+-green)](https://nodejs.org)
@@ -153,35 +154,74 @@ The evolution engine then:
 npx homunculus-code init
 ```
 
-The wizard asks you a few questions and sets everything up:
+```
+Homunculus — Self-evolving AI Assistant
+
+✓ Created homunculus/ directory structure
+✓ Added evolution rules
+✓ Copied evolution scripts
+✓ Added slash commands (/hm-setup, /hm-night, /hm-status)
+✓ Configured observation hook
 
+Done! Homunculus is installed.
+
+Next steps:
+  1. Run claude to open Claude Code
+  2. Type /hm-setup to define your goals (AI-guided)
+  3. Type /hm-night to run your first evolution cycle
 ```
-🧬 Homunculus — Self-evolving AI Assistant
 
-? What's your project name? my-app
-? What's your main goal? Build a reliable SaaS product
+### 2. Define Your Goals
 
-✅ Created homunculus/ structure
-✅ Generated architecture.yaml with your goals
-✅ Added observation hook to Claude Code
-✅ Copied evolution scripts
+Open Claude Code and type `/hm-setup`. Claude will have a short conversation with you to understand your project and goals, then generate your `architecture.yaml` automatically.
 
-Done! Start using Claude Code. Your assistant will evolve.
 ```
+> /hm-setup
 
-### 2. Use Claude Code Normally
+Claude: What kind of project is this?
+You:    A SaaS app for team collaboration
 
-That's it. The system observes, extracts, and evolves in the background. Check progress anytime:
+Claude: What do you spend most time on?
+You:    Debugging auth issues and writing tests
 
-```bash
-claude "/eval-skill"         # Run skill evaluations
-claude "/improve-skill"      # Auto-improve a skill
-claude "/evolve"             # Converge instincts into skills
+Claude: Here's your goal tree:
+        🎯 Team Collaboration SaaS
+        ├── code_quality — Ship fewer bugs
+        │   ├── testing — Every change has tests
+        │   └── auth_reliability — Auth works every time
+        ├── productivity — Move faster
+        │   └── debugging — Find root causes faster
+        └── knowledge — Stay current
+            └── tool_updates — Track Claude Code updates
+
+        Does this look right?
+You:    Yes!
+
+Claude: ✅ architecture.yaml created with 5 goals!
 ```
 
-### 3. Refine Your Goals (Optional)
+### 3. Run Your First Evolution Cycle
+
+```
+> /hm-night
+```
+
+Watch Claude check your goals, scan for patterns, evaluate skills, and generate a report — all in one command. This is what the nightly agent does autonomously while you sleep.
+
+### 4. Keep Using Claude Code
+
+The observation hook watches your usage automatically. As patterns emerge:
+
+```
+/hm-night       Run an evolution cycle
+/hm-status      Check evolution progress
+/hm-setup       Refine your goals anytime
+/eval-skill     Evaluate a specific skill
+/improve-skill  Auto-improve a skill
+/evolve         Converge instincts into skills
+```
 
-As you use the system, refine `architecture.yaml` — add sub-goals, metrics, and health checks. The more specific your goals, the smarter the evolution.
+Set up the [nightly agent](docs/nightly-agent.md) to run `/hm-night` autonomously while you sleep.
 
 ---
 

package/bin/cli.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+// homunculus-code CLI — entry point
+
+const command = process.argv[2];
+
+switch (command) {
+  case 'init':
+    require('./init.js');
+    break;
+  case 'night':
+    require('./night.js');
+    break;
+  case 'help':
+  case '--help':
+  case '-h':
+  case undefined:
+    console.log('');
+    console.log('  \x1b[1mHomunculus\x1b[0m — Self-evolving AI Assistant for Claude Code');
+    console.log('');
+    console.log('  Usage:');
+    console.log('    npx homunculus-code <command>');
+    console.log('');
+    console.log('  Commands:');
+    console.log('    init     Set up Homunculus in your project');
+    console.log('    night    Run one evolution cycle (health check → evolve → report)');
+    console.log('    help     Show this help message');
+    console.log('');
+    console.log('  After init, use Claude Code normally. Evolution happens automatically.');
+    console.log('  Run "night" anytime to trigger a manual evolution cycle.');
+    console.log('');
+    break;
+  default:
+    console.error(`  Unknown command: ${command}`);
+    console.error('  Run "npx homunculus-code help" for available commands.');
+    process.exit(1);
+}

package/bin/init.js

@@ -1,44 +1,17 @@
 #!/usr/bin/env node
-// homunculus init — Set up a self-evolving AI assistant in your project
+// homunculus init — Set up the evolution structure in your project
 
 const fs = require('fs');
 const path = require('path');
-const readline = require('readline');
 
 const TEMPLATES_DIR = path.join(__dirname, '..', 'templates');
 const CORE_DIR = path.join(__dirname, '..', 'core');
 const COMMANDS_DIR = path.join(__dirname, '..', 'commands');
 
-const YES_MODE = process.argv.includes('--yes') || process.argv.includes('-y');
-
-let rl;
-if (!YES_MODE) {
-  rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-}
-
-function ask(question, defaultVal) {
-  if (YES_MODE) return Promise.resolve(process.env[`HOMUNCULUS_${question.replace(/[^A-Z]/gi, '_').toUpperCase()}`] || defaultVal || '');
-  return new Promise(resolve => {
-    const suffix = defaultVal ? ` (${defaultVal})` : '';
-    rl.question(`${question}${suffix}: `, answer => {
-      resolve(answer.trim() || defaultVal || '');
-    });
-  });
-}
-
 function ensureDir(dir) {
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
 }
 
-function copyFile(src, dest) {
-  if (fs.existsSync(src)) {
-    fs.copyFileSync(src, dest);
-  }
-}
-
 function copyDir(src, dest) {
   ensureDir(dest);
   if (!fs.existsSync(src)) return;
@@ -53,18 +26,9 @@ function copyDir(src, dest) {
   }
 }
 
-function replaceTemplateVars(content, vars) {
-  let result = content;
-  for (const [key, value] of Object.entries(vars)) {
-    result = result.replace(new RegExp(`\\{\\{${key}\\}\\}`, 'g'), value);
-  }
-  return result;
-}
-
-async function main() {
+function main() {
   console.log('');
   console.log('  \x1b[1mHomunculus\x1b[0m — Self-evolving AI Assistant');
-  console.log('  A seed that grows into your own AI assistant.');
   console.log('');
 
   const projectDir = process.cwd();
@@ -75,128 +39,6 @@ async function main() {
     console.log('');
   }
 
-  // Gather info
-  const projectName = await ask('  Project name', path.basename(projectDir));
-  const purpose = await ask('  What is this project\'s main goal?', 'My evolving AI assistant');
-
-  console.log('');
-  console.log('  Select areas you want your AI to improve in:');
-  console.log('');
-
-  const goalOptions = [
-    { key: '1', name: 'code_quality', label: 'Code Quality', desc: 'Ship fewer bugs, better tests' },
-    { key: '2', name: 'productivity', label: 'Productivity', desc: 'Complete tasks faster' },
-    { key: '3', name: 'debugging', label: 'Debugging', desc: 'Faster root cause analysis' },
-    { key: '4', name: 'documentation', label: 'Documentation', desc: 'Keep docs up to date' },
-    { key: '5', name: 'automation', label: 'Automation', desc: 'Automate repetitive work' },
-    { key: '6', name: 'learning', label: 'Continuous Learning', desc: 'Stay up to date with tools and patterns' },
-  ];
-
-  for (const opt of goalOptions) {
-    console.log(`    ${opt.key}. ${opt.label} — ${opt.desc}`);
-  }
-  console.log('');
-
-  const selectedStr = await ask('  Select areas (enter numbers, e.g. 1,2,5)', '1,2');
-  const selectedKeys = selectedStr.split(/[,\s]+/).map(s => s.trim()).filter(Boolean);
-  const selectedGoals = goalOptions.filter(o => selectedKeys.includes(o.key));
-  if (selectedGoals.length === 0) selectedGoals.push(goalOptions[0], goalOptions[1]);
-
-  console.log('');
-
-  const vars = {
-    PROJECT_NAME: projectName,
-    PROJECT_PURPOSE: purpose
-  };
-
-  // Generate architecture.yaml from selected goals
-  function generateArchitecture(goals, rootPurpose) {
-    let yaml = `# architecture.yaml — Your goal tree\n`;
-    yaml += `# Goals are stable. Implementations evolve.\n`;
-    yaml += `# See: https://github.com/JavanC/Homunculus\n\n`;
-    yaml += `version: "1.0"\n\n`;
-    yaml += `root:\n`;
-    yaml += `  purpose: "${rootPurpose}"\n\n`;
-    yaml += `  goals:\n`;
-
-    const goalTemplates = {
-      code_quality: {
-        purpose: 'Ship fewer bugs, write more maintainable code',
-        goals: {
-          testing: { purpose: 'Every change has tests', realized_by: '# will evolve' },
-          review: { purpose: 'Catch issues before merge', realized_by: '# will evolve' }
-        },
-        metrics: [{ name: 'test_pass_rate', healthy: '> 90%' }]
-      },
-      productivity: {
-        purpose: 'Complete tasks faster with fewer iterations',
-        goals: {
-          task_completion: { purpose: 'Finish tasks in fewer cycles', realized_by: '# will evolve' },
-          tool_mastery: { purpose: 'Use the right tool on first try', realized_by: '# will evolve' }
-        },
-        metrics: [{ name: 'avg_iterations_per_task', healthy: 'decreasing trend' }]
-      },
-      debugging: {
-        purpose: 'Find and fix bugs faster',
-        goals: {
-          root_cause: { purpose: 'Identify root causes, not symptoms', realized_by: '# will evolve' },
-          diagnosis_tools: { purpose: 'Use the right debugging approach', realized_by: '# will evolve' }
-        },
-        metrics: [{ name: 'avg_debug_time', healthy: 'decreasing trend' }]
-      },
-      documentation: {
-        purpose: 'Keep documentation accurate and up to date',
-        goals: {
-          api_docs: { purpose: 'API docs match implementation', realized_by: '# will evolve' },
-          decision_records: { purpose: 'Document why, not just what', realized_by: '# will evolve' }
-        },
-        metrics: [{ name: 'doc_freshness', healthy: '< 1 week behind code' }]
-      },
-      automation: {
-        purpose: 'Automate repetitive work',
-        goals: {
-          ci_cd: { purpose: 'Automated build, test, deploy', realized_by: '# will evolve' },
-          workflows: { purpose: 'Common sequences as one command', realized_by: '# will evolve' }
-        },
-        metrics: [{ name: 'manual_steps_per_deploy', healthy: '< 3' }]
-      },
-      learning: {
-        purpose: 'Stay up to date with tools and best practices',
-        goals: {
-          tool_updates: { purpose: 'Track and adopt useful updates', realized_by: '# will evolve' },
-          pattern_discovery: { purpose: 'Find better ways to do things', realized_by: '# will evolve' }
-        },
-        metrics: [{ name: 'patterns_adopted_per_month', healthy: '> 2' }]
-      }
-    };
-
-    for (const goal of goals) {
-      const tmpl = goalTemplates[goal.name];
-      if (!tmpl) continue;
-      yaml += `    ${goal.name}:\n`;
-      yaml += `      purpose: "${tmpl.purpose}"\n`;
-      if (tmpl.metrics) {
-        yaml += `      metrics:\n`;
-        for (const m of tmpl.metrics) {
-          yaml += `        - name: ${m.name}\n`;
-          yaml += `          healthy: "${m.healthy}"\n`;
-        }
-      }
-      if (tmpl.goals) {
-        yaml += `      goals:\n`;
-        for (const [subName, sub] of Object.entries(tmpl.goals)) {
-          yaml += `        ${subName}:\n`;
-          yaml += `          purpose: "${sub.purpose}"\n`;
-          yaml += `          realized_by: ${sub.realized_by}\n`;
-        }
-      }
-      yaml += `\n`;
-    }
-
-    yaml += `    # Add more goals as your system evolves...\n`;
-    return yaml;
-  }
-
   // 1. Create directory structure
   const dirs = [
     'homunculus/instincts/personal',
@@ -205,6 +47,7 @@ async function main() {
     'homunculus/evolved/agents',
     'homunculus/evolved/evals',
     'homunculus/experiments',
+    'homunculus/reports',
     'scripts',
     '.claude/rules',
     '.claude/commands'
@@ -215,51 +58,37 @@ async function main() {
   }
   console.log('  \x1b[32m✓\x1b[0m Created homunculus/ directory structure');
 
-  // 2. Generate architecture.yaml from selected goals
-  const archDest = path.join(projectDir, 'architecture.yaml');
-  if (!fs.existsSync(archDest)) {
-    const archContent = generateArchitecture(selectedGoals, purpose);
-    fs.writeFileSync(archDest, archContent);
-    console.log(`  \x1b[32m✓\x1b[0m Created architecture.yaml with ${selectedGoals.length} goals: ${selectedGoals.map(g => g.label).join(', ')}`);
-  } else {
-    console.log('  \x1b[33m-\x1b[0m architecture.yaml already exists, skipping');
+  // 2. Copy evolution rules
+  const rulesSrc = path.join(TEMPLATES_DIR, 'rules', 'evolution-system.md');
+  const rulesDest = path.join(projectDir, '.claude', 'rules', 'evolution-system.md');
+  if (!fs.existsSync(rulesDest) && fs.existsSync(rulesSrc)) {
+    fs.copyFileSync(rulesSrc, rulesDest);
+    console.log('  \x1b[32m✓\x1b[0m Added evolution rules');
   }
 
-  // 3. Copy CLAUDE.md template (append if exists)
+  // 3. Copy CLAUDE.md template
+  const claudeSrc = path.join(TEMPLATES_DIR, 'CLAUDE.md.template');
   const claudeDest = path.join(projectDir, 'CLAUDE.md');
-  if (!fs.existsSync(claudeDest)) {
-    const template = fs.readFileSync(
-      path.join(TEMPLATES_DIR, 'CLAUDE.md.template'), 'utf8'
-    );
-    fs.writeFileSync(claudeDest, replaceTemplateVars(template, vars));
+  if (!fs.existsSync(claudeDest) && fs.existsSync(claudeSrc)) {
+    const template = fs.readFileSync(claudeSrc, 'utf8');
+    const projectName = path.basename(projectDir);
+    fs.writeFileSync(claudeDest, template.replace(/\{\{PROJECT_NAME\}\}/g, projectName));
     console.log('  \x1b[32m✓\x1b[0m Created CLAUDE.md');
-  } else {
-    console.log('  \x1b[33m-\x1b[0m CLAUDE.md already exists, skipping');
   }
 
-  // 4. Copy evolution rules
-  const rulesDest = path.join(projectDir, '.claude', 'rules', 'evolution-system.md');
-  if (!fs.existsSync(rulesDest)) {
-    copyFile(
-      path.join(TEMPLATES_DIR, 'rules', 'evolution-system.md'),
-      rulesDest
-    );
-    console.log('  \x1b[32m✓\x1b[0m Created .claude/rules/evolution-system.md');
-  }
-
-  // 5. Copy core scripts
+  // 4. Copy core scripts
   if (fs.existsSync(CORE_DIR)) {
     copyDir(CORE_DIR, path.join(projectDir, 'scripts'));
-    console.log('  \x1b[32m✓\x1b[0m Copied evolution scripts to scripts/');
+    console.log('  \x1b[32m✓\x1b[0m Copied evolution scripts');
   }
 
-  // 6. Copy slash commands
+  // 5. Copy slash commands
   if (fs.existsSync(COMMANDS_DIR)) {
     copyDir(COMMANDS_DIR, path.join(projectDir, '.claude', 'commands'));
-    console.log('  \x1b[32m✓\x1b[0m Copied slash commands to .claude/commands/');
+    console.log('  \x1b[32m✓\x1b[0m Added slash commands (/hm-setup, /hm-night, /hm-status)');
   }
 
-  // 7. Configure Claude Code hooks (if settings exist)
+  // 6. Configure Claude Code hooks
   const settingsPath = path.join(projectDir, '.claude', 'settings.json');
   let settings = {};
   if (fs.existsSync(settingsPath)) {
@@ -275,10 +104,10 @@ async function main() {
     }];
     ensureDir(path.join(projectDir, '.claude'));
     fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
-    console.log('  \x1b[32m✓\x1b[0m Configured Claude Code observation hook');
+    console.log('  \x1b[32m✓\x1b[0m Configured observation hook');
   }
 
-  // 8. Create .gitignore additions
+  // 7. Create .gitignore additions
   const gitignorePath = path.join(projectDir, '.gitignore');
   const gitignoreEntries = [
     '',
@@ -299,19 +128,15 @@ async function main() {
     console.log('  \x1b[32m✓\x1b[0m Created .gitignore');
   }
 
+  // Done
   console.log('');
-  console.log('  \x1b[1m\x1b[32mDone!\x1b[0m Your assistant is ready to evolve.');
+  console.log('  \x1b[1m\x1b[32mDone!\x1b[0m Homunculus is installed.');
   console.log('');
   console.log('  Next steps:');
-  console.log('  1. Edit \x1b[1marchitecture.yaml\x1b[0m to define your goals');
-  console.log('  2. Use Claude Code normally — the system observes automatically');
-  console.log('  3. Run \x1b[1mclaude "/eval-skill"\x1b[0m to check evolution progress');
+  console.log('    1. Run \x1b[1mclaude\x1b[0m to open Claude Code');
+  console.log('    2. Type \x1b[1m/hm-setup\x1b[0m to define your goals (AI-guided)');
+  console.log('    3. Type \x1b[1m/hm-night\x1b[0m to run your first evolution cycle');
   console.log('');
-
-  if (rl) rl.close();
 }
 
-main().catch(err => {
-  console.error('Error:', err.message);
-  process.exit(1);
-});
+main();