homunculus-code 0.2.0 → 0.3.0

package/README.md

@@ -154,65 +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
+Homunculus — Self-evolving AI Assistant
 
-? What's your project name? my-app
-? What's your main goal? Build a reliable SaaS product
+✓ Created homunculus/ directory structure
+✓ Added evolution rules
+✓ Copied evolution scripts
+✓ Added slash commands (/hm-setup, /hm-night, /hm-status)
+✓ Configured observation hook
 
-✅ Created homunculus/ structure
-✅ Generated architecture.yaml with your goals
-✅ Added observation hook to Claude Code
-✅ Copied evolution scripts
+Done! Homunculus is installed.
 
-Done! Start using Claude Code. Your assistant will evolve.
+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
 ```
 
-### 2. Run Your First Evolution Cycle
+### 2. Define Your Goals
+
+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.
 
-```bash
-npx homunculus-code night
 ```
+> /hm-setup
 
-Watch the system check your goals, scan for patterns, and generate a report:
+Claude: What kind of project is this?
+You:    A SaaS app for team collaboration
 
-```
-🌙 Homunculus — Evolution Cycle
+Claude: What do you spend most time on?
+You:    Debugging auth issues and writing tests
 
-[1/5] Health Check
-      code_quality:    ○ no data yet
-      productivity:    ○ no data yet
+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
 
-[2/5] Scan Instincts
-      ○ No instincts yet — use Claude Code normally, patterns will emerge
+        Does this look right?
+You:    Yes!
 
-[3/5] Eval Skills
-      ○ No skills yet — instincts converge into skills over time
+Claude: ✅ architecture.yaml created with 5 goals!
+```
 
-[4/5] Research
-      ✓ Claude Code 2.1.81
-      △ 0/7 goals have health checks — add more for better evolution
+### 3. Run Your First Evolution Cycle
 
-[5/5] Report
-  ┌────────────────────────────────────────────┐
-  │  Evolution Report — 2026-03-22             │
-  │  Goals: 7 | Instincts: 0 | Skills: 0      │
-  │  Status: Fresh install — ready to evolve   │
-  └────────────────────────────────────────────┘
+```
+> /hm-night
 ```
 
-### 3. Use Claude Code Normally
+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.
 
-The observation hook watches your usage automatically. As patterns emerge, run `night` again to see your system evolve. Or set up the [nightly agent](docs/nightly-agent.md) to do it autonomously while you sleep.
+### 4. Keep Using Claude Code
+
+The observation hook watches your usage automatically. As patterns emerge:
 
-```bash
-npx homunculus-code night    # Manual evolution cycle
-claude "/eval-skill"         # Evaluate a specific skill
-claude "/improve-skill"      # Auto-improve a skill
-claude "/evolve"             # Converge instincts into skills
 ```
+/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
+```
+
+Set up the [nightly agent](docs/nightly-agent.md) to run `/hm-night` autonomously while you sleep.
 
 ---
 

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();

package/commands/hm-night.md

@@ -0,0 +1,86 @@
+# /hm-night — Run One Evolution Cycle
+
+Run the full evolution pipeline: health check → instincts → skills → research → report.
+
+## Behavior
+
+You are the Homunculus nightly evolution agent. Run through all 5 phases systematically.
+
+### Phase 1: Health Check
+
+1. Read `architecture.yaml`
+2. For each goal with a `health_check.command`, run it and report pass/fail
+3. For goals without health checks, check if `realized_by` points to an existing file
+4. Report:
+   ```
+   [1/5] Health Check
+         code_quality:    ✅ healthy (tests passing)
+         productivity:    ⚠️ no health check defined
+         knowledge:       ✅ healthy
+   ```
+
+### Phase 2: Scan Instincts
+
+1. Count files in `homunculus/instincts/personal/` and `homunculus/instincts/archived/`
+2. If instincts exist, check for pruning candidates (run `node scripts/prune-instincts.js` if it exists)
+3. Report count and any archival suggestions
+   ```
+   [2/5] Instincts
+         12 active / 5 archived
+         △ 2 candidates for archival (low confidence)
+   ```
+
+### Phase 3: Eval Skills
+
+1. List files in `homunculus/evolved/skills/`
+2. For each skill, check if an eval spec exists in `homunculus/evolved/evals/`
+3. If eval specs exist, run `/eval-skill` on each
+4. Report pass rates
+   ```
+   [3/5] Skills
+         ✓ tdd-workflow: 100% (8/8 scenarios)
+         △ debugging-patterns: 85% (6/7) — needs improvement
+   ```
+
+### Phase 4: Research
+
+1. Check Claude Code version
+2. Scan `architecture.yaml` for goals with no `realized_by` — these are opportunities
+3. Look for goals with failing health checks — these need attention
+4. Suggest improvements:
+   ```
+   [4/5] Research
+         ✓ Claude Code v2.1.81
+         △ 2 goals have no implementation yet
+         → Suggestion: code_quality.review could use a pre-commit hook
+   ```
+
+### Phase 5: Report
+
+Generate a summary report and save to `homunculus/reports/YYYY-MM-DD.md`:
+
+```
+[5/5] Evolution Report — 2026-03-22
+┌──────────────────────────────────────────┐
+│  Goals:      5 (3 healthy, 2 need work)  │
+│  Instincts:  12 active / 5 archived      │
+│  Skills:     3 (2 at 100%, 1 at 85%)     │
+│                                          │
+│  Actions taken:                          │
+│  - Pruned 2 outdated instincts           │
+│  - Improved debugging-patterns to v1.2   │
+│                                          │
+│  Suggestions:                            │
+│  - Add health check to productivity goal │
+│  - Review could use a pre-commit hook    │
+└──────────────────────────────────────────┘
+```
+
+## Important
+
+- Actually RUN health check commands (don't just read them)
+- Actually RUN eval-skill if eval specs exist (don't skip)
+- If a skill fails eval, attempt `/improve-skill` (max 2 rounds)
+- Save the report to `homunculus/reports/`
+- Be concise — this should feel like a progress dashboard, not an essay
+- If the system is fresh (no instincts/skills), give encouraging guidance

package/commands/hm-setup.md

@@ -0,0 +1,65 @@
+# /hm-setup — Set Up Your Goal Tree
+
+Guide the user through defining their goals and generate `architecture.yaml`.
+
+## Behavior
+
+You are helping the user set up Homunculus — a self-evolving AI assistant. Your job is to understand their project and goals, then generate a goal tree.
+
+### Step 1: Understand the Project
+
+Ask the user (conversationally, not a form):
+- What is this project? (e.g., SaaS app, CLI tool, personal project)
+- What do they spend most time on? (e.g., debugging, writing tests, deploying)
+- What frustrates them? (e.g., regressions, slow CI, repetitive tasks)
+- What would they improve if they had infinite time?
+
+Keep it natural — 2-3 questions max, adapt based on answers.
+
+### Step 2: Propose Goals
+
+Based on their answers, propose 3-5 goals with sub-goals. Present them clearly:
+
+```
+Based on what you told me, here's your goal tree:
+
+🎯 [Project Name]
+├── code_quality — Ship fewer bugs
+│   ├── testing — Every change has tests
+│   └── review — Catch issues before merge
+├── productivity — Move faster
+│   ├── automation — Automate repetitive work
+│   └── debugging — Find root causes faster
+└── knowledge — Stay up to date
+    └── tool_updates — Track useful updates
+```
+
+Ask: "Does this look right? Want to add, remove, or change anything?"
+
+### Step 3: Generate architecture.yaml
+
+Once confirmed, generate `architecture.yaml` with:
+- `purpose` for every goal
+- `metrics` where measurable (use reasonable defaults)
+- `health_check` where possible (shell commands that exit 0 = healthy)
+- `realized_by: # will evolve` for all implementations (the system will fill these in)
+
+Write the file using the Write tool.
+
+### Step 4: Confirm
+
+```
+✅ architecture.yaml created with N goals!
+
+Your system is ready to evolve. Use Claude Code normally —
+patterns will be auto-extracted. Run /hm-night anytime to
+trigger an evolution cycle.
+```
+
+## Important
+
+- Keep the conversation SHORT (under 5 back-and-forth)
+- Generate PRACTICAL goals, not abstract ones
+- Use the project's actual tech stack for health checks (e.g., `npm test`, `pytest`, `go test`)
+- Don't overwhelm — 3-5 top-level goals is ideal for a start
+- Goals can always be refined later

package/commands/hm-status.md

@@ -0,0 +1,47 @@
+# /hm-status — Evolution Status Dashboard
+
+Show the current state of the Homunculus evolution system.
+
+## Behavior
+
+Gather and display all evolution metrics in a compact dashboard.
+
+### Data to Collect
+
+1. **Goal Tree**: Read `architecture.yaml`, count goals and sub-goals
+2. **Instincts**: Count files in `homunculus/instincts/personal/` and `archived/`
+3. **Skills**: Count files in `homunculus/evolved/skills/`, note versions
+4. **Agents**: Count files in `homunculus/evolved/agents/`
+5. **Eval Specs**: Count files in `homunculus/evolved/evals/`
+6. **Observations**: Count lines in `homunculus/observations.jsonl`
+7. **Experiments**: Count files in `homunculus/experiments/`
+8. **Reports**: List recent reports in `homunculus/reports/`
+
+### Output Format
+
+```
+🧬 Homunculus Status
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Goal Tree:     5 goals / 12 sub-goals
+Instincts:     24 active / 8 archived
+Skills:        3 evolved (all 100% eval)
+Agents:        1 specialized
+Observations:  1,247 recorded
+Experiments:   2 completed / 1 queued
+
+Recent Skills:
+  ✓ tdd-workflow v1.2 — 100% (11 scenarios)
+  ✓ debugging-patterns v1.1 — 100% (8 scenarios)
+  ✓ shell-automation v1.0 — 100% (6 scenarios)
+
+Last Evolution: 2026-03-22
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## Important
+
+- Use actual file counts, not hardcoded numbers
+- Keep output compact — one screen max
+- If the system is fresh, show zeros and next steps
+- Don't run any evaluations — just report current state

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homunculus-code",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "A self-evolving AI assistant that grows smarter every night",
   "bin": {
     "homunculus-code": "./bin/cli.js"