metame-cli 1.4.31 → 1.4.33

package/scripts/schema.js

@@ -9,7 +9,7 @@
  *
  * Tiers:
  *   T1 — Identity (LOCKED, never auto-modify)
- *   T2 — Core Values (LOCKED, deep personality)
+ *   T2 — Soul (LOCKED, 6-dimension personality model)
  *   T3 — Preferences (auto-writable, needs confidence)
  *   T5 — Evolution (system-managed, strict limits)
  *
@@ -23,14 +23,47 @@ const SCHEMA = {
   'identity.role': { tier: 'T1', type: 'string', locked: false },
   'identity.locale': { tier: 'T1', type: 'string', locked: true },
 
-  // === T2: Core Values / Traits ===
-  'core_values.*': { tier: 'T2', type: 'string', locked: true },
-  'core_traits.crisis_reflex': { tier: 'T2', type: 'enum', locked: true, values: ['Action', 'Analysis', 'Delegation', 'Freeze'] },
-  'core_traits.flow_trigger': { tier: 'T2', type: 'enum', locked: true, values: ['Ideation', 'Execution', 'Teaching', 'Debugging'] },
-  'core_traits.shadow_self': { tier: 'T2', type: 'string', locked: true, maxChars: 80 },
-  'core_traits.learning_style': { tier: 'T2', type: 'enum', locked: true, values: ['Hands-on', 'Conceptual', 'Social', 'Reflective'] },
-  'core_traits.north_star.aspiration': { tier: 'T2', type: 'string', locked: true, maxChars: 80 },
-  'core_traits.north_star.realistic': { tier: 'T2', type: 'string', locked: true, maxChars: 80 },
+  // === T2: Soul (6-Dimension Model, LOCKED) ===
+
+  // Dim 1: Values (Schwartz Value Theory)
+  'soul.values.primary': { tier: 'T2', type: 'string', locked: true, maxChars: 40 },
+  'soul.values.secondary': { tier: 'T2', type: 'string', locked: true, maxChars: 40 },
+  'soul.values.anti_value': { tier: 'T2', type: 'string', locked: true, maxChars: 40 },
+
+  // Dim 2: Drive (Self-Determination Theory)
+  'soul.drive.primary_need': { tier: 'T2', type: 'enum', locked: true,
+    values: ['autonomy', 'mastery', 'connection', 'impact', 'security', 'novelty', 'meaning'] },
+  'soul.drive.flow_trigger': { tier: 'T2', type: 'string', locked: true, maxChars: 60 },
+  'soul.drive.north_star.aspiration': { tier: 'T2', type: 'string', locked: true, maxChars: 80 },
+  'soul.drive.north_star.realistic': { tier: 'T2', type: 'string', locked: true, maxChars: 80 },
+
+  // Dim 3: Cognition Style (Jung + Kahneman)
+  'soul.cognition_style.thinking_axis': { tier: 'T2', type: 'enum', locked: true,
+    values: ['systematic', 'intuitive', 'dialectical'] },
+  'soul.cognition_style.learning_mode': { tier: 'T2', type: 'enum', locked: true,
+    values: ['by_doing', 'by_modeling', 'by_abstracting', 'by_debating', 'by_reflecting'] },
+  'soul.cognition_style.complexity_appetite': { tier: 'T2', type: 'enum', locked: true,
+    values: ['reductionist', 'comfortable_with_ambiguity', 'complexity_seeker'] },
+
+  // Dim 4: Stress & Shadow (Jung Shadow + Resilience Theory)
+  'soul.stress.crisis_reflex': { tier: 'T2', type: 'enum', locked: true,
+    values: ['fight', 'flight', 'freeze', 'analyze'] },
+  'soul.stress.shadow': { tier: 'T2', type: 'string', locked: true, maxChars: 80 },
+  'soul.stress.recovery_pattern': { tier: 'T2', type: 'enum', locked: true,
+    values: ['solitude', 'social_support', 'physical_action', 'intellectual_distraction', 'sleep_reset'] },
+
+  // Dim 5: Relational (Attachment Theory + FIRO-B)
+  'soul.relational.trust_formation': { tier: 'T2', type: 'enum', locked: true,
+    values: ['competence_first', 'character_first', 'shared_experience', 'slow_incremental'] },
+  'soul.relational.conflict_style': { tier: 'T2', type: 'enum', locked: true,
+    values: ['direct_confrontation', 'strategic_avoidance', 'diplomatic_mediation', 'withdrawal'] },
+  'soul.relational.authority_stance': { tier: 'T2', type: 'enum', locked: true,
+    values: ['challenge_authority', 'respect_hierarchy', 'pragmatic_compliance', 'build_own_authority'] },
+
+  // Dim 6: Identity Narrative (McAdams Narrative Identity)
+  'soul.identity_narrative.self_in_one_line': { tier: 'T2', type: 'string', locked: true, maxChars: 100 },
+  'soul.identity_narrative.core_contradiction': { tier: 'T2', type: 'string', locked: true, maxChars: 80 },
+  'soul.identity_narrative.feared_self': { tier: 'T2', type: 'string', locked: true, maxChars: 60 },
 
   // === T3: Preferences ===
   'preferences.code_style': { tier: 'T3', type: 'enum', values: ['concise', 'verbose', 'documented'] },
@@ -80,7 +113,7 @@ const SCHEMA = {
 
 /**
  * Check if a dotted key matches the schema.
- * Supports wildcard entries like 'core_values.*'
+ * Supports wildcard entries (e.g. 'namespace.*') and exact dotted keys.
  */
 function hasKey(key) {
   if (SCHEMA[key]) return true;

package/scripts/skill-evolution.test.js

@@ -12,10 +12,16 @@ function mkHome() {
   return fs.mkdtempSync(path.join(os.tmpdir(), 'metame-skill-evo-'));
 }
 
+function homeEnv(home) {
+  return process.platform === 'win32'
+    ? { HOME: home, USERPROFILE: home }
+    : { HOME: home };
+}
+
 function runWithHome(home, code) {
   return execFileSync(process.execPath, ['-e', code], {
     cwd: ROOT,
-    env: { ...process.env, HOME: home },
+    env: { ...process.env, ...homeEnv(home) },
     encoding: 'utf8',
   });
 }

package/scripts/sync-readme.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * sync-readme.js — Translate README.md (English) → README中文版.md
+ *
+ * Usage: node scripts/sync-readme.js
+ * Or:    npm run sync:readme
+ *
+ * Uses claude CLI to translate. English README is the source of truth.
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..');
+const SRC = path.join(ROOT, 'README.md');
+const DST = path.join(ROOT, 'README中文版.md');
+
+const english = fs.readFileSync(SRC, 'utf8');
+
+const prompt = `You are a professional translator. Translate the following GitHub README from English to Chinese (简体中文).
+
+Rules:
+- Keep ALL markdown formatting, links, code blocks, HTML tags, and badges EXACTLY as-is
+- Keep all technical terms, CLI commands, file paths, and config examples in English
+- Translate prose, descriptions, and comments naturally — not word-by-word
+- The first tagline should be: > **住在你电脑里的数字分身。**
+- Change "Your machine, your data" to "不上云。你的机器，你的数据。"
+- Keep the <p align="center"> header block unchanged
+- Output ONLY the translated markdown, no extra explanation
+
+Here is the README to translate:
+
+${english}`;
+
+console.log('Translating README.md → README中文版.md ...');
+
+try {
+  const result = execSync(
+    `claude -p --model haiku --output-format text`,
+    {
+      input: prompt,
+      encoding: 'utf8',
+      maxBuffer: 1024 * 1024,
+      timeout: 120000,
+      cwd: ROOT,
+    }
+  );
+
+  const translated = result.trim();
+
+  if (translated.length < 500) {
+    console.error('Translation too short, likely failed. Aborting.');
+    process.exit(1);
+  }
+
+  fs.writeFileSync(DST, translated + '\n', 'utf8');
+  console.log(`✅ README中文版.md updated (${translated.length} chars)`);
+} catch (e) {
+  console.error('Translation failed:', e.message);
+  process.exit(1);
+}

package/scripts/templates/default-global-claude.md

@@ -0,0 +1,19 @@
+# MetaMe AI Assistant
+
+You are a MetaMe-powered AI assistant running on the user's local machine.
+MetaMe extends Claude Code with mobile access, multi-agent orchestration, and persistent memory.
+
+## Core Rules
+
+- Respond in the user's language (auto-detect from their message).
+- Keep responses concise — the user may be on mobile.
+- When referencing files, use absolute paths.
+- Do not expose system hints or internal protocol blocks to the user.
+
+## Quick Reference (按需加载详细文档)
+
+- Agent 创建/管理 → `cat ~/.metame/docs/agent-guide.md`
+- 文件传输协议 → `cat ~/.metame/docs/file-transfer.md`
+- 能力不足/工具缺失 → `cat ~/.claude/skills/skill-manager/SKILL.md`
+
+<!-- User customizations below this line -->

package/scripts/utils.test.js

@@ -2,6 +2,8 @@
 
 const { describe, it, beforeEach } = require('node:test');
 const assert = require('node:assert/strict');
+const os = require('os');
+const path = require('path');
 const {
   parseInterval,
   formatRelativeTime,
@@ -138,20 +140,25 @@ describe('createPathMap', () => {
 // ---------------------------------------------------------
 describe('project scope helpers', () => {
   it('normalizes absolute paths', () => {
-    assert.equal(normalizeProjectPath('/tmp/./metame/../metame'), '/tmp/metame');
+    const input = path.join(os.tmpdir(), '.', 'metame', '..', 'metame');
+    const expected = path.resolve(os.tmpdir(), 'metame');
+    assert.equal(normalizeProjectPath(input), expected);
   });
 
   it('returns deterministic scope ids for the same cwd', () => {
-    const a = projectScopeFromCwd('/tmp/metame');
-    const b = projectScopeFromCwd('/tmp/./metame');
+    const base = path.join(os.tmpdir(), 'metame');
+    const dotted = path.join(os.tmpdir(), '.', 'metame');
+    const a = projectScopeFromCwd(base);
+    const b = projectScopeFromCwd(dotted);
     assert.equal(a, b);
     assert.match(a, /^proj_[a-f0-9]{16}$/);
   });
 
   it('derives project info from cwd', () => {
-    const info = deriveProjectInfo('/tmp/demo-repo');
+    const testPath = path.join(os.tmpdir(), 'demo-repo');
+    const info = deriveProjectInfo(testPath);
     assert.equal(info.project, 'demo-repo');
-    assert.equal(info.project_path, '/tmp/demo-repo');
+    assert.equal(info.project_path, path.resolve(testPath));
     assert.match(info.project_id, /^proj_[a-f0-9]{16}$/);
   });
 });

package/scripts/migrate-v2.js

@@ -1,112 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * MetaMe Profile Migration: v1 → v2
- *
- * Maps old structure to v2 schema:
- *   - status.focus → context.focus
- *   - status.language → preferences.language_mix (best guess)
- *   - Ensures all v2 sections exist with defaults
- *   - Preserves all existing data and LOCKED comments
- *
- * Usage: node migrate-v2.js [--dry-run]
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const BRAIN_FILE = path.join(os.homedir(), '.claude_profile.yaml');
-const BACKUP_SUFFIX = '.v1.backup';
-const DRY_RUN = process.argv.includes('--dry-run');
-
-function migrate() {
-  if (!fs.existsSync(BRAIN_FILE)) {
-    console.log('No profile found. Nothing to migrate.');
-    return;
-  }
-
-  const yaml = require('js-yaml');
-  const rawContent = fs.readFileSync(BRAIN_FILE, 'utf8');
-  const profile = yaml.load(rawContent) || {};
-
-  // Check if already v2 (has context section)
-  if (profile.context && profile.context.focus !== undefined) {
-    console.log('Profile already appears to be v2. Skipping migration.');
-    return;
-  }
-
-  console.log('Migrating profile from v1 to v2...');
-
-  // --- Backup ---
-  if (!DRY_RUN) {
-    const backupPath = BRAIN_FILE + BACKUP_SUFFIX;
-    fs.writeFileSync(backupPath, rawContent, 'utf8');
-    console.log(`  Backup saved to: ${backupPath}`);
-  }
-
-  // --- Migration rules ---
-
-  // 1. status.focus → context.focus
-  if (profile.status && profile.status.focus) {
-    if (!profile.context) profile.context = {};
-    profile.context.focus = profile.status.focus;
-    profile.context.focus_since = new Date().toISOString().slice(0, 10);
-    delete profile.status.focus;
-  }
-
-  // 2. status.language → status.language (keep, it's in schema)
-  // No change needed, status.language is valid in v2
-
-  // 3. Clean up empty status object
-  if (profile.status && Object.keys(profile.status).length === 0) {
-    delete profile.status;
-  }
-
-  // 4. Ensure context section exists with defaults
-  if (!profile.context) profile.context = {};
-  if (profile.context.focus === undefined) profile.context.focus = null;
-  if (profile.context.focus_since === undefined) profile.context.focus_since = null;
-  if (profile.context.active_projects === undefined) profile.context.active_projects = [];
-  if (profile.context.blockers === undefined) profile.context.blockers = [];
-  if (profile.context.energy === undefined) profile.context.energy = null;
-
-  // 5. Ensure evolution section exists
-  if (!profile.evolution) profile.evolution = {};
-  if (profile.evolution.last_distill === undefined) profile.evolution.last_distill = null;
-  if (profile.evolution.distill_count === undefined) profile.evolution.distill_count = 0;
-  if (profile.evolution.recent_changes === undefined) profile.evolution.recent_changes = [];
-
-  // 6. Ensure preferences section exists (don't overwrite existing values)
-  if (!profile.preferences) profile.preferences = {};
-
-  // --- Output ---
-  const dumped = yaml.dump(profile, { lineWidth: -1 });
-
-  // Restore LOCKED comments from original
-  const lockedLines = rawContent.split('\n').filter(l => l.includes('# [LOCKED]'));
-  let restored = dumped;
-  for (const lockedLine of lockedLines) {
-    const match = lockedLine.match(/^\s*([\w_]+)\s*:\s*(.+?)\s+(#.+)$/);
-    if (match) {
-      const key = match[1];
-      const comment = match[3];
-      // Find the corresponding line in dumped output and append comment
-      restored = restored.replace(
-        new RegExp(`^(\\s*${key}\\s*:.+)$`, 'm'),
-        (line) => line.includes('#') ? line : `${line} ${comment}`
-      );
-    }
-  }
-
-  if (DRY_RUN) {
-    console.log('\n--- DRY RUN (would write): ---');
-    console.log(restored);
-    console.log('--- END DRY RUN ---');
-  } else {
-    fs.writeFileSync(BRAIN_FILE, restored, 'utf8');
-    console.log('  Migration complete. Profile is now v2.');
-  }
-}
-
-migrate();

package/scripts/self-reflect.js

@@ -1,285 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * self-reflect.js — Daily Self-Reflection Task
- *
- * Scans correction/metacognitive signals from the past 7 days,
- * aggregates "where did the AI get it wrong", and writes a brief
- * self-critique pattern into growth.patterns in ~/.claude_profile.yaml.
- *
- * Also distills correction signals into lessons/ SOP markdown files.
- *
- * Heartbeat: nightly at 23:00, require_idle, non-blocking.
- */
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const { callHaiku, buildDistillEnv } = require('./providers');
-const { writeBrainFileSafe } = require('./utils');
-
-const HOME = os.homedir();
-const SIGNAL_FILE = path.join(HOME, '.metame', 'raw_signals.jsonl');
-const BRAIN_FILE = path.join(HOME, '.claude_profile.yaml');
-const LOCK_FILE = path.join(HOME, '.metame', 'self-reflect.lock');
-const LESSONS_DIR = path.join(HOME, '.metame', 'memory', 'lessons');
-const WINDOW_DAYS = 7;
-
-/**
- * Distill correction signals into reusable SOP markdown files.
- * Each run produces at most one lesson file per unique slug.
- * Returns the number of lesson files actually written.
- *
- * @param {Array} signals - all recent signals (will filter to 'correction' type internally)
- * @param {string} lessonsDir - absolute path where lesson .md files are written
- */
-async function generateLessons(signals, lessonsDir) {
-  // Only process correction signals that carry explicit feedback
-  const corrections = signals.filter(s => s.type === 'correction' && s.feedback);
-  if (corrections.length < 2) {
-    console.log(`[self-reflect] Only ${corrections.length} correction signal(s) with feedback, skipping lessons.`);
-    return 0;
-  }
-
-  fs.mkdirSync(lessonsDir, { recursive: true });
-
-  const correctionText = corrections
-    .slice(-15) // cap to avoid prompt bloat
-    .map(c => `- Prompt: ${(c.prompt || '').slice(0, 100)}\n  Feedback: ${(c.feedback || '').slice(0, 150)}`)
-    .join('\n');
-
-  const prompt = `You are distilling correction signals into a reusable SOP for an AI assistant.
-
-Corrections (JSON):
-${correctionText}
-
-Generate ONE actionable lesson in this JSON format:
-{
-  "title": "简短标题（中文，10字以内）",
-  "slug": "kebab-case-english-slug",
-  "content": "## 问题\\n...\\n## 根因\\n...\\n## 操作手册\\n1. ...\\n2. ...\\n3. ..."
-}
-
-Rules: content must be in 中文, concrete and actionable, 100-300 chars total.
-Only output the JSON object, no explanation.`;
-
-  let distillEnv = {};
-  try { distillEnv = buildDistillEnv(); } catch {}
-
-  let result;
-  try {
-    result = await Promise.race([
-      callHaiku(prompt, distillEnv, 60000),
-      new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 90000)),
-    ]);
-  } catch (e) {
-    console.log(`[self-reflect] generateLessons Haiku call failed: ${e.message}`);
-    return 0;
-  }
-
-  let lesson;
-  try {
-    const cleaned = result.replace(/```json\n?/g, '').replace(/```\n?/g, '').trim();
-    lesson = JSON.parse(cleaned);
-    if (!lesson.title || !lesson.slug || !lesson.content) throw new Error('missing fields');
-  } catch (e) {
-    console.log(`[self-reflect] Failed to parse lesson JSON: ${e.message}`);
-    return 0;
-  }
-
-  // Sanitize slug: only lowercase alphanumeric and hyphens
-  const slug = (lesson.slug || '').toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
-  if (!slug) {
-    console.log('[self-reflect] generateLessons: empty slug, skipping');
-    return 0;
-  }
-
-  // Prevent duplicates: skip if any existing file already uses this slug
-  const existing = fs.readdirSync(lessonsDir).filter(f => f.endsWith(`-${slug}.md`));
-  if (existing.length > 0) {
-    console.log(`[self-reflect] Lesson '${slug}' already exists (${existing[0]}), skipping.`);
-    return 0;
-  }
-
-  const today = new Date().toISOString().slice(0, 10);
-  const filename = `${today}-${slug}.md`;
-  const filepath = path.join(lessonsDir, filename);
-
-  const fileContent = `---
-date: ${today}
-source: self-reflect
-corrections: ${corrections.length}
----
-
-# ${lesson.title}
-
-${lesson.content}
-`;
-
-  fs.writeFileSync(filepath, fileContent, 'utf8');
-  console.log(`[self-reflect] Lesson written: ${filepath}`);
-  return 1;
-}
-
-async function run() {
-  // Atomic lock
-  let lockFd;
-  try {
-    lockFd = fs.openSync(LOCK_FILE, 'wx');
-    fs.writeSync(lockFd, process.pid.toString());
-    fs.closeSync(lockFd);
-  } catch (e) {
-    if (e.code === 'EEXIST') {
-      const age = Date.now() - fs.statSync(LOCK_FILE).mtimeMs;
-      if (age < 300000) { console.log('[self-reflect] Already running.'); return; }
-      fs.unlinkSync(LOCK_FILE);
-      try {
-        lockFd = fs.openSync(LOCK_FILE, 'wx');
-      } catch {
-        // Another process acquired the lock
-        return;
-      }
-      fs.writeSync(lockFd, process.pid.toString());
-      fs.closeSync(lockFd);
-    } else throw e;
-  }
-
-  try {
-    // Read signals from last WINDOW_DAYS days
-    if (!fs.existsSync(SIGNAL_FILE)) {
-      console.log('[self-reflect] No signal file, skipping.');
-      return;
-    }
-
-    const cutoff = Date.now() - WINDOW_DAYS * 24 * 60 * 60 * 1000;
-    const lines = fs.readFileSync(SIGNAL_FILE, 'utf8').trim().split('\n').filter(Boolean);
-    const recentSignals = lines
-      .map(l => { try { return JSON.parse(l); } catch { return null; } })
-      .filter(s => s && s.ts && new Date(s.ts).getTime() > cutoff);
-
-    // Filter to correction + metacognitive signals only
-    const correctionSignals = recentSignals.filter(s =>
-      s.type === 'correction' || s.type === 'metacognitive'
-    );
-
-    if (correctionSignals.length < 2) {
-      console.log(`[self-reflect] Only ${correctionSignals.length} correction signals this week, skipping.`);
-      return;
-    }
-
-    // Read current profile for context
-    let currentPatterns = '';
-    try {
-      const yaml = require('js-yaml');
-      const profile = yaml.load(fs.readFileSync(BRAIN_FILE, 'utf8')) || {};
-      const existing = (profile.growth && profile.growth.patterns) || [];
-      if (existing.length > 0) {
-        currentPatterns = `Current growth.patterns (avoid repeating):\n${existing.map(p => `- ${p}`).join('\n')}\n\n`;
-      }
-    } catch { /* non-fatal */ }
-
-    const signalText = correctionSignals
-      .slice(-20) // cap at 20 signals
-      .map((s, i) => `${i + 1}. [${s.type}] "${s.prompt}"`)
-      .join('\n');
-
-    const prompt = `你是一个AI自我审视引擎。分析以下用户纠正/元认知信号，找出AI（即你）**系统性**犯错的模式。
-
-${currentPatterns}用户纠正信号（最近7天）：
-${signalText}
-
-任务：找出1-2条AI的系统性问题（不是偶发错误），例如：
-- "经常过度简化用户的技术问题，忽略背景细节"
-- "倾向于在用户还没说完就开始行动，导致方向偏差"
-- "在不确定时倾向于肯定用户，而非直接说不知道"
-
-输出格式（JSON数组，最多2条，每条≤40字中文）：
-["模式1描述", "模式2描述"]
-
-注意：
-- 只输出有充分证据支持的系统性模式
-- 如果证据不足，输出 []
-- 只输出JSON，不要解释`;
-
-    let distillEnv = {};
-    try { distillEnv = buildDistillEnv(); } catch {}
-
-    let result;
-    try {
-      result = await Promise.race([
-        callHaiku(prompt, distillEnv, 60000),
-        // outer safety net in case callHaiku's internal timeout doesn't propagate
-        new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 90000)),
-      ]);
-    } catch (e) {
-      console.log(`[self-reflect] Haiku call failed: ${e.message}`);
-      return;
-    }
-
-    // Parse result
-    let patterns = [];
-    try {
-      const cleaned = result.replace(/```json\n?/g, '').replace(/```\n?/g, '').trim();
-      const parsed = JSON.parse(cleaned);
-      if (Array.isArray(parsed)) {
-        patterns = parsed.filter(p => typeof p === 'string' && p.length > 5 && p.length <= 80);
-      }
-    } catch {
-      console.log('[self-reflect] Failed to parse Haiku output.');
-      return;
-    }
-
-    // === Generate lessons/ from correction signals (independent of patterns result) ===
-    try {
-      const lessonsCount = await generateLessons(recentSignals, LESSONS_DIR);
-      if (lessonsCount > 0) {
-        console.log(`[self-reflect] Generated ${lessonsCount} lesson(s) in ${LESSONS_DIR}`);
-      }
-    } catch (e) {
-      console.log(`[self-reflect] generateLessons failed (non-fatal): ${e.message}`);
-    }
-
-    if (patterns.length === 0) {
-      console.log('[self-reflect] No patterns found this week.');
-      return;
-    }
-
-    // Merge into growth.patterns (cap at 3, keep newest)
-    try {
-      const yaml = require('js-yaml');
-      const raw = fs.readFileSync(BRAIN_FILE, 'utf8');
-      const profile = yaml.load(raw) || {};
-      if (!profile.growth) profile.growth = {};
-      const existing = Array.isArray(profile.growth.patterns) ? profile.growth.patterns : [];
-      // Add new patterns, deduplicate, cap at 3 newest
-      const merged = [...existing, ...patterns]
-        .filter((p, i, arr) => arr.indexOf(p) === i)
-        .slice(-3);
-      profile.growth.patterns = merged;
-      profile.growth.last_reflection = new Date().toISOString().slice(0, 10);
-
-      // Preserve locked lines (simple approach: only update growth section)
-      const dumped = yaml.dump(profile, { lineWidth: -1 });
-      await writeBrainFileSafe(dumped);
-      console.log(`[self-reflect] ${patterns.length} pattern(s) written to growth.patterns: ${patterns.join(' | ')}`);
-    } catch (e) {
-      console.log(`[self-reflect] Failed to write profile: ${e.message}`);
-    }
-
-  } finally {
-    try { fs.unlinkSync(LOCK_FILE); } catch {}
-  }
-}
-
-if (require.main === module) {
-  run().then(() => {
-    console.log('✅ self-reflect complete');
-  }).catch(e => {
-    console.error(`[self-reflect] Fatal: ${e.message}`);
-    process.exit(1);
-  });
-}
-
-module.exports = { run };