metame-cli 1.4.32 → 1.4.33

package/README.md

@@ -1,7 +1,7 @@
 # MetaMe
 
 <p align="center">
-  <img src="./logo.png" alt="MetaMe Logo" width="200"/>
+  <img src="./logo_high_contrast.png" alt="MetaMe Logo" width="200"/>
 </p>
 
 <p align="center">

package/index.js

@@ -50,6 +50,41 @@ if (!fs.existsSync(METAME_DIR)) {
   fs.mkdirSync(METAME_DIR, { recursive: true });
 }
 
+// ---------------------------------------------------------
+// DEPLOY PHASE: sync scripts, docs, bin to ~/.metame/
+// ---------------------------------------------------------
+
+/**
+ * Sync files from srcDir to destDir. Only writes when content differs.
+ * @param {string} srcDir - source directory
+ * @param {string} destDir - destination directory
+ * @param {object} [opts]
+ * @param {string[]} [opts.fileList] - explicit file list (skip readdirSync)
+ * @param {number}  [opts.chmod] - chmod after write (e.g. 0o755)
+ * @returns {boolean} true if any file was updated
+ */
+function syncDirFiles(srcDir, destDir, { fileList, chmod } = {}) {
+  if (!fs.existsSync(srcDir)) return false;
+  if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
+  let updated = false;
+  const files = fileList || fs.readdirSync(srcDir).filter(f => fs.statSync(path.join(srcDir, f)).isFile());
+  for (const f of files) {
+    const src = path.join(srcDir, f);
+    const dest = path.join(destDir, f);
+    try {
+      if (!fs.existsSync(src)) continue;
+      const srcContent = fs.readFileSync(src, 'utf8');
+      const destContent = fs.existsSync(dest) ? fs.readFileSync(dest, 'utf8') : '';
+      if (srcContent !== destContent) {
+        fs.writeFileSync(dest, srcContent, 'utf8');
+        if (chmod) try { fs.chmodSync(dest, chmod); } catch { /* Windows */ }
+        updated = true;
+      }
+    } catch { /* non-fatal per file */ }
+  }
+  return updated;
+}
+
 // Auto-deploy bundled scripts to ~/.metame/
 // IMPORTANT: daemon.yaml is USER CONFIG — never overwrite it. Only daemon-default.yaml (template) is synced.
 const scriptsDir = path.join(__dirname, 'scripts');
@@ -75,23 +110,7 @@ try {
   }
 } catch { /* non-fatal */ }
 
-let scriptsUpdated = false;
-for (const script of BUNDLED_SCRIPTS) {
-  const src = path.join(scriptsDir, script);
-  const dest = path.join(METAME_DIR, script);
-  try {
-    if (fs.existsSync(src)) {
-      const srcContent = fs.readFileSync(src, 'utf8');
-      const destContent = fs.existsSync(dest) ? fs.readFileSync(dest, 'utf8') : '';
-      if (srcContent !== destContent) {
-        fs.writeFileSync(dest, srcContent, 'utf8');
-        scriptsUpdated = true;
-      }
-    }
-  } catch {
-    // Non-fatal
-  }
-}
+const scriptsUpdated = syncDirFiles(scriptsDir, METAME_DIR, { fileList: BUNDLED_SCRIPTS });
 
 // Daemon restart on script update:
 // Don't kill daemon here — daemon's own file watcher detects ~/.metame/daemon.js changes
@@ -101,6 +120,11 @@ if (scriptsUpdated) {
   console.log(`${icon("pkg")} Scripts synced to ~/.metame/ — daemon will auto-restart when idle.`);
 }
 
+// Docs: lazy-load references for CLAUDE.md pointer instructions
+syncDirFiles(path.join(__dirname, 'scripts', 'docs'), path.join(METAME_DIR, 'docs'));
+// Bin: CLI tools (dispatch_to etc.)
+syncDirFiles(path.join(__dirname, 'scripts', 'bin'), path.join(METAME_DIR, 'bin'), { chmod: 0o755 });
+
 // ---------------------------------------------------------
 // Deploy bundled skills to ~/.claude/skills/
 // Only installs if not already present — never overwrites user customizations.
@@ -750,16 +774,20 @@ const CAPABILITY_SECTIONS = [
   `"告诉X/让X" → \`~/.metame/bin/dispatch_to <project_key> "内容"\`，手机端 \`/dispatch to <key> <消息>\`。` + dispatchTable,
   '新增 Agent：`/agent bind <名称> <工作目录>`',
   '',
+  '## Agent 创建与管理',
+  '用户问创建/管理/绑定 Agent 时 → 先 `cat ~/.metame/docs/agent-guide.md` 再回答。',
+  '',
+  '## 手机端文件交互',
+  '用户要文件（"发给我"/"发过来"/"导出"）→ 先 `cat ~/.metame/docs/file-transfer.md` 再执行。',
+  '**收**：用户发图片/文件自动存到 `upload/`，用 Read 查看。',
+  '**发**：回复末尾加 `[[FILE:/absolute/path]]`，daemon 自动发手机。不要读内容再复述。',
+  '',
   '## 跨会话记忆',
   '用户提"上次/之前"时搜索：`node ~/.metame/memory-search.js "关键词1" "keyword2"`',
   '一次传 3-4 个关键词（中文+英文+函数名），`--facts` 只搜事实，`--sessions` 只搜会话。',
   '',
   '## Skills',
   '能力不足/工具缺失/任务失败 → 先查 `cat ~/.claude/skills/skill-manager/SKILL.md`，不要自己猜。',
-  '',
-  '## 手机端文件交互',
-  '**收**：用户发图片/文件自动存到 `upload/`，用 Read 查看。',
-  '**发**：回复末尾加 `[[FILE:/absolute/path]]`，daemon 自动发手机。不要读内容再复述。',
 
 ].join('\n');
 
@@ -778,6 +806,14 @@ try {
     ), '');
   }
 
+  // New user: seed with default template if CLAUDE.md is empty or missing
+  if (!globalContent.trim()) {
+    const tplPath = path.join(__dirname, 'scripts', 'templates', 'default-global-claude.md');
+    if (fs.existsSync(tplPath)) {
+      globalContent = fs.readFileSync(tplPath, 'utf8');
+    }
+  }
+
   const injection =
     GLOBAL_MARKER_START + '\n' +
     KERNEL_BODY + '\n\n' +

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.4.32",
+    "version": "1.4.33",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {

package/scripts/bin/dispatch_to

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+/**
+ * dispatch_to [--new] <project_key> "<prompt>"
+ * Tries Unix socket / Named Pipe first (low-latency), falls back to pending.jsonl.
+ */
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const net = require('net');
+const crypto = require('crypto');
+const os = require('os');
+const { socketPath } = require('../platform');
+
+const args = process.argv.slice(2);
+const newSession = args[0] === '--new' ? (args.shift(), true) : false;
+const [target, ...rest] = args;
+const prompt = rest.join(' ').replace(/^["']|["']$/g, '');
+if (!target || !prompt) {
+  console.error('Usage: dispatch_to [--new] <project_key> "<prompt>"');
+  process.exit(1);
+}
+
+const METAME_DIR = path.join(os.homedir(), '.metame');
+const DISPATCH_DIR = path.join(METAME_DIR, 'dispatch');
+const PENDING = path.join(DISPATCH_DIR, 'pending.jsonl');
+const DISPATCH_SECRET_FILE = path.join(METAME_DIR, '.dispatch_secret');
+const SOCK_PATH = socketPath(METAME_DIR);
+
+function getDispatchSecret() {
+  try {
+    if (fs.existsSync(DISPATCH_SECRET_FILE)) {
+      return fs.readFileSync(DISPATCH_SECRET_FILE, 'utf8').trim();
+    }
+  } catch { /* fall through to generate */ }
+  const secret = crypto.randomBytes(32).toString('hex');
+  try {
+    fs.writeFileSync(DISPATCH_SECRET_FILE, secret, { mode: 0o600 });
+  } catch { /* ignore write errors */ }
+  return secret;
+}
+
+const ts = new Date().toISOString();
+const secret = getDispatchSecret();
+const sigPayload = JSON.stringify({ target, prompt, ts });
+const sig = crypto.createHmac('sha256', secret).update(sigPayload).digest('hex');
+
+const msg = { target, prompt, from: '_claude_session', new_session: newSession, created_at: ts, ts, sig };
+
+function fallbackToFile() {
+  fs.mkdirSync(DISPATCH_DIR, { recursive: true });
+  fs.appendFileSync(PENDING, JSON.stringify(msg) + '\n');
+  console.log(`DISPATCH_OK(file): ${target} → ${prompt.slice(0, 60)}${newSession ? ' [new session]' : ''}`);
+}
+
+const sock = net.createConnection({ path: SOCK_PATH });
+let done = false;
+
+const timer = setTimeout(() => {
+  if (done) return;
+  done = true;
+  sock.destroy();
+  fallbackToFile();
+}, 2000);
+
+sock.on('connect', () => {
+  sock.write(JSON.stringify(msg));
+  sock.end();
+});
+
+sock.on('data', (data) => {
+  if (done) return;
+  done = true;
+  clearTimeout(timer);
+  try {
+    const res = JSON.parse(data.toString().trim());
+    if (res.ok) {
+      console.log(`DISPATCH_OK(socket): ${target} → ${prompt.slice(0, 60)}${newSession ? ' [new session]' : ''}`);
+    } else {
+      fallbackToFile();
+    }
+  } catch {
+    fallbackToFile();
+  }
+  sock.destroy();
+});
+
+sock.on('error', () => {
+  if (done) return;
+  done = true;
+  clearTimeout(timer);
+  fallbackToFile();
+});

package/scripts/docs/agent-guide.md

@@ -0,0 +1,50 @@
+# Agent 创建与管理指南
+
+## 创建 Agent（完整流程）
+
+用户说"创建agent"、"新建agent"、"帮我建个agent"时，按此流程引导：
+
+### Step 1: 收集信息
+需要两个必要信息：
+- **工作目录**：Agent 的代码/项目目录（如 `~/projects/my-bot`）
+- **角色描述**（可选）：Agent 的职责定义
+
+如果用户没给目录，提示：
+> 请告诉我 Agent 的工作目录，例如 `~/projects/my-bot`
+
+### Step 2: 执行创建
+在手机端（飞书/Telegram），直接说即可，daemon 会自动处理：
+> 创建一个 Agent，目录是 ~/projects/my-bot
+
+在桌面 Claude Code 终端，需要手动操作：
+1. 创建项目目录和 CLAUDE.md（角色定义）
+2. 编辑 `~/.metame/daemon.yaml`，在 `projects` 下新增：
+   ```yaml
+   projects:
+     my_bot:
+       name: "我的机器人"
+       cwd: "~/projects/my-bot"
+       icon: "🤖"
+   ```
+3. 运行 `touch ~/.metame/daemon.js` 触发热重载
+
+### Step 3: 绑定群聊
+告知用户：
+> 请在飞书/Telegram 新建群组，把 bot 加进去，发送 `/activate` 完成绑定。
+
+`/activate` 会自动将群与最近创建的 Agent 绑定（30分钟内有效）。
+
+## 常用命令速查
+
+| 操作 | 手机端命令 |
+|------|-----------|
+| 新建 Agent | `/agent new` 或自然语言"创建agent" |
+| 绑定群 | `/activate` 或 `/agent bind <名称> [目录]` |
+| 查看列表 | `/agent list` |
+| 编辑角色 | `/agent edit` |
+| 解绑群 | `/agent unbind` |
+| 切换 Agent | 直接@昵称（仅非专属群） |
+
+## 注意事项
+- 专属群（chat_agent_map 中的群）永远绑定同一个 Agent，不能通过昵称切换
+- 新群必须发 `/activate` 才能使用，未授权群会提示"此群未授权"

package/scripts/docs/file-transfer.md

@@ -0,0 +1,32 @@
+# 文件传输协议
+
+## 用户要文件（发送到手机）
+
+当用户说"把xx发给我"、"文件发过来"、"发个截图"、"导出给我"等**任何要求获取文件**的场景：
+
+1. 找到文件路径（用 Glob/ls 搜索）
+2. **不要读取文件内容**（浪费 token）
+3. 在回复末尾加标记：`[[FILE:/absolute/path/to/file]]`
+4. 多个文件用多个标记
+
+示例回复：
+```
+请查收~! [[FILE:/Users/xxx/project/output.pdf]]
+```
+
+多文件：
+```
+这是你要的文件：
+[[FILE:/path/to/report.pdf]]
+[[FILE:/path/to/data.xlsx]]
+```
+
+## 用户发文件（从手机上传）
+
+用户从手机发送的图片/文件会自动保存到当前项目的 `upload/` 目录。
+直接用 Read 工具读取 `upload/` 下的文件即可。
+
+## 关键规则
+- **永远不要读取再复述文件内容**，直接用 `[[FILE:...]]` 标记发送
+- 路径必须是绝对路径
+- daemon 会自动解析标记并通过 bot 发送给用户

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/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 };