metame-cli 1.5.4 → 1.5.6

package/scripts/docs/hook-config.md

@@ -15,7 +15,8 @@ Stop (每轮结束)
   └── stop-session-capture.js → session 事件日志 + 工具失败捕获
 ```
 
-`intent-engine.js` 是统一入口，调用各意图模块，合并输出。
+`scripts/intent-registry.js` 是单一维护源，负责调用各意图模块并返回提示块。
+`intent-engine.js` 是 Claude hook adapter；daemon 里的 Codex 路径也复用同一 registry。
 零匹配 → 零输出（不浪费 token）。
 
 ---
@@ -29,8 +30,7 @@ Stop (每轮结束)
 | `task_create` | `intent-task-create.js` | 定时/提醒/每天X点 等调度语境 | `/task-add` 命令用法提示 |
 | `file_transfer` | `intent-file-transfer.js` | "发给我/发过来/导出" 等文件传输语境 | `[[FILE:...]]` 协议 + 收发规则 |
 | `memory_recall` | `intent-memory-recall.js` | "上次/之前/还记得" 等跨会话回忆语境 | `memory-search.js` 命令用法 |
-| `agent_manage` | `intent-agent-manage.js` | "创建/绑定 Agent" 或 "代码结构/脚本入口" | agent-guide / pointer-map 文档指引 |
-| `hook_config` | `intent-hook-config.js` | "hook/intent 配置/开关" 等引擎配置语境 | hook-config.md 文档指引 |
+| `doc_router` | `intent-doc-router.js` | "创建/绑定 Agent"、"代码结构/脚本入口"、"hook/intent 配置" 等文档导向语境 | 统一 doc-router 文档指引 |
 ---
 
 ## 开关控制
@@ -85,6 +85,8 @@ const DEFAULTS = {
 };
 ```
 
+文档路由类场景优先复用 `scripts/hooks/doc-router.js`，只传 `patterns + title + docPath + summary`，不要再为每个文档问题单独建样板模块。
+
 3. **在 daemon.yaml 加开关**（可选，默认开）：
 
 ```yaml
@@ -124,7 +126,8 @@ for k, v in s.get('hooks', {}).items():
 
 | 文件 | 说明 |
 |------|------|
-| `scripts/hooks/intent-engine.js` | 引擎主入口（源文件） |
+| `scripts/intent-registry.js` | 共享意图注册表（Claude hook / Codex runtime 共用） |
+| `scripts/hooks/intent-engine.js` | Claude hook adapter（源文件） |
 | `~/.metame/hooks/intent-engine.js` | 部署副本（symlink） |
 | `scripts/hooks/intent-*.js` | 各意图模块（源文件） |
 | `~/.metame/daemon.yaml` | 用户配置（包含 `hooks:` 开关） |

package/scripts/docs/maintenance-manual.md

@@ -147,7 +147,7 @@ feishu:
 - ENGINE_MODEL_CONFIG（daemon-engine-runtime.js 集中管理）
 - daemon-runtime-lifecycle.js 的语法检查和备份机制
 - daemon-remote-dispatch.js（纯逻辑，无平台差异）
-- team-dispatch.js（共享解析/hint/enrichment）
+- daemon-team-dispatch.js（共享解析/hint/enrichment）
 
 ### 需分别维护（有平台/引擎特殊分支）
 
@@ -263,7 +263,7 @@ team 成员可以通过 `peer` 字段标记为"远端成员"——运行在另
 
 ### 配置
 
-两台设备的 `daemon.yaml` 需要配置相同的 relay 群和共享密钥，不同的 `self` 标识：
+两台设备的 `daemon.yaml` 需要配置相同的 relay 群和共享密钥，不同的 `self` 标识；但不能共用同一个飞书 bot。每台机器都必须使用自己独立的飞书应用 / bot 凭据。
 
 ```yaml
 # Mac 端
@@ -283,6 +283,13 @@ feishu:
     secret: shared-secret-key    # 同一个密钥
 ```
 
+注意：
+
+- 可以共用同一个 relay 群。
+- 可以共用同一个 `secret`。
+- 不能共用同一个飞书 bot / `app_id` / `app_secret`。
+- 原因是飞书对同一 bot 的事件投递可能随机落到任一在线客户端；而当前代码在收到 `to_peer !== self` 的 relay 包时会直接忽略，错误机器会把包吞掉。
+
 team 成员添加 `peer` 字段指向远端设备：
 
 ```yaml
@@ -338,7 +345,7 @@ Claude 看到 hook 注入:
 | `daemon-bridges.js` | Feishu bridge 拦截 relay 群消息 + `_dispatchToTeamMember` 远端分流 |
 | `daemon-admin-commands.js` | `/dispatch peers` 查看配置 + `/dispatch to peer:project` 手动派发 |
 | `scripts/bin/dispatch_to` | 支持 `peer:project` 格式 → 写 `remote-pending.jsonl` |
-| `team-dispatch.js` | `buildTeamRosterHint()` 为远端成员生成 `peer:key` 格式命令 |
+| `daemon-team-dispatch.js` | `buildTeamRosterHint()` 为远端成员生成 `peer:key` 格式命令 |
 | `hooks/team-context.js` | intent hook 注入远端 `peer:key` dispatch 命令 |
 
 ### 管理命令

package/scripts/docs/pointer-map.md

@@ -64,7 +64,7 @@
 ## 团队 Dispatch 与跨设备通信定位
 
 - 共享 Dispatch 工具：
-  - `scripts/team-dispatch.js`
+  - `scripts/daemon-team-dispatch.js`
   - 关键点：`resolveProjectKey()` 名称/昵称解析（含 team member `parent/member` 复合键）；
     `findTeamMember()` 文本前缀匹配团队成员昵称；
     `buildTeamRosterHint()` 生成团队上下文块（远端成员自动带 `peer:key` 前缀）；
@@ -156,7 +156,7 @@
 1. 先看配置：`~/.metame/daemon.yaml` 与 `scripts/daemon-default.yaml`
 2. 再看命令入口：`scripts/daemon-admin-commands.js`、`scripts/daemon-command-router.js`、`scripts/daemon-exec-commands.js`
 3. 再看执行链路：`scripts/daemon-engine-runtime.js` → `scripts/daemon-claude-engine.js` → `scripts/mentor-engine.js`
-4. 团队/跨设备：`scripts/team-dispatch.js` → `scripts/daemon-remote-dispatch.js` → `scripts/daemon-bridges.js`
+4. 团队/跨设备：`scripts/daemon-team-dispatch.js` → `scripts/daemon-remote-dispatch.js` → `scripts/daemon-bridges.js`
 5. 最后看离线任务：`scripts/distill.js`、`scripts/memory-extract.js`、`scripts/memory-nightly-reflect.js`
 
 ## 同步提示

package/scripts/feishu-adapter.js

@@ -298,16 +298,8 @@ function createBot(config) {
         throw new Error(`File not found: ${filePath}`);
       }
       const fileName = path.basename(filePath);
-      const fileSize = fs.statSync(filePath).size;
-
-      // For text files under 4KB, just send as text
       const ext = path.extname(filePath).toLowerCase();
       const isText = ['.md', '.txt', '.json', '.yaml', '.yml', '.csv'].includes(ext);
-      if (isText && fileSize < 4096) {
-        const content = fs.readFileSync(filePath, 'utf8');
-        await this.sendMessage(chatId, `📄 ${fileName}:\n\`\`\`\n${content}\n\`\`\``);
-        return;
-      }
 
       // For larger/binary files, try file upload
       try {
@@ -332,7 +324,7 @@ function createBot(config) {
         }
 
         // 2. Send file message
-        await client.im.message.create({
+        const sendRes = await client.im.message.create({
           params: { receive_id_type: 'chat_id' },
           data: {
             receive_id: chatId,
@@ -340,6 +332,9 @@ function createBot(config) {
             content: JSON.stringify({ file_key: fileKey }),
           },
         });
+        const msgId = sendRes?.data?.message_id;
+        if (caption) await this.sendMessage(chatId, caption);
+        return msgId ? { message_id: msgId } : null;
       } catch (uploadErr) {
         // Log detailed error
         const errDetail = uploadErr.response?.data || uploadErr.message || uploadErr;
@@ -349,18 +344,15 @@ function createBot(config) {
         if (isText) {
           const content = fs.readFileSync(filePath, 'utf8');
           const truncated = content.length > 3000 ? content.slice(0, 3000) + '\n...(truncated)' : content;
-          await this.sendMessage(chatId, `📄 ${fileName}:\n\`\`\`\n${truncated}\n\`\`\``);
+          const textMsg = await this.sendMessage(chatId, `📄 ${fileName}:\n\`\`\`\n${truncated}\n\`\`\``);
+          if (caption) await this.sendMessage(chatId, caption);
+          return textMsg || null;
         } else {
           // For binary files, give more helpful error
           const errMsg = errDetail?.msg || errDetail?.message || '上传失败';
           throw new Error(`${errMsg} (请检查飞书应用权限: im:resource)`);
         }
       }
-
-      // 3. Send caption as separate message if provided
-      if (caption) {
-        await this.sendMessage(chatId, caption);
-      }
     },
 
     /**

package/scripts/hooks/doc-router.js

@@ -0,0 +1,29 @@
+'use strict';
+
+/**
+ * Build a unified doc-routing hint for intent modules.
+ *
+ * @param {object} route
+ * @param {RegExp[]} route.patterns
+ * @param {string} route.title
+ * @param {string} route.docPath
+ * @param {string} route.summary
+ * @returns {(prompt: string) => string|null}
+ */
+function createDocRoute(route) {
+  const patterns = Array.isArray(route.patterns) ? route.patterns : [];
+  const title = String(route.title || '').trim();
+  const docPath = String(route.docPath || '').trim();
+  const summary = String(route.summary || '').trim();
+
+  if (!patterns.length || !title || !docPath || !summary) {
+    throw new Error('doc-router requires patterns, title, docPath, and summary');
+  }
+
+  return function detectDocRoute(prompt) {
+    if (!patterns.some((re) => re.test(prompt))) return null;
+    return `[${title}]\n- ${summary} → 先 \`cat ${docPath}\``;
+  };
+}
+
+module.exports = { createDocRoute };

package/scripts/hooks/intent-doc-router.js

@@ -0,0 +1,54 @@
+'use strict';
+
+/**
+ * Doc Router Intent Module
+ *
+ * Detects documentation-oriented intents and routes the model
+ * to the right handbook/index with a unified hint format.
+ *
+ * @param {string} prompt
+ * @returns {string|null}
+ */
+
+const { createDocRoute } = require('./doc-router');
+
+const routes = [
+  createDocRoute({
+    patterns: [
+      /(?:创建|新建|添加|注册|绑定|配置|管理).{0,8}(?:agent|机器人|bot|智能体)/i,
+      /(?:agent|bot|智能体).{0,8}(?:创建|新建|添加|注册|绑定|配置|管理)/i,
+      /\b(?:create|add|register|bind|manage|setup|configure)\s+(?:an?\s+)?agent\b/i,
+    ],
+    title: 'Agent 管理提示',
+    docPath: '~/.metame/docs/agent-guide.md',
+    summary: '创建/管理/绑定 Agent',
+  }),
+  createDocRoute({
+    patterns: [
+      /(?:代码结构|脚本入口|升级进度|模块关系|文件结构)/,
+      /(?:pointer.?map|架构图|入口文件)/i,
+    ],
+    title: '代码结构提示',
+    docPath: '~/.metame/docs/pointer-map.md',
+    summary: '代码结构/脚本入口/升级进度',
+  }),
+  createDocRoute({
+    patterns: [
+      /(?:hook|intent|意图).{0,10}(?:配置|设置|开关|新增|添加|修改|怎么配|怎么设置|怎么改)/i,
+      /(?:配置|设置|开关|新增|添加|修改).{0,10}(?:hook|intent|意图)/i,
+      /intent.?engine/i,
+      /意图引擎|意图模块/,
+    ],
+    title: 'Intent Engine 配置提示',
+    docPath: '~/.metame/docs/hook-config.md',
+    summary: 'Hook/Intent 配置操作',
+  }),
+];
+
+module.exports = function detectDocRouter(prompt) {
+  const hints = routes
+    .map((detect) => detect(prompt))
+    .filter(Boolean);
+
+  return hints.length ? hints.join('\n') : null;
+};

package/scripts/hooks/intent-engine.js

@@ -25,28 +25,7 @@ const os = require('os');
 
 const METAME_DIR = path.join(os.homedir(), '.metame');
 const { sanitizePrompt, isInternalPrompt } = require('./hook-utils');
-
-// Default: all intents enabled unless explicitly set to false in daemon.yaml
-const DEFAULTS = {
-  team_dispatch:  true,
-  ops_assist:     true,
-  task_create:    true,
-  file_transfer:  true,
-  memory_recall:  true,
-  agent_manage:   true,
-  hook_config:    true,
-};
-
-// Intent registry — loaded lazily so startup is fast even if a module has issues
-const INTENT_MODULES = {
-  team_dispatch:  './intent-team-dispatch',
-  ops_assist:     './intent-ops-assist',
-  task_create:    './intent-task-create',
-  file_transfer:  './intent-file-transfer',
-  memory_recall:  './intent-memory-recall',
-  agent_manage:   './intent-agent-manage',
-  hook_config:    './intent-hook-config',
-};
+const { buildIntentHintBlock } = require('../intent-registry');
 
 function exit() { process.exit(0); }
 
@@ -77,27 +56,17 @@ function run(data) {
     config = yaml.load(fs.readFileSync(path.join(METAME_DIR, 'daemon.yaml'), 'utf8')) || {};
   } catch { /* proceed with defaults */ }
 
-  // Merge daemon.yaml hooks section with defaults
-  const hooksCfg = (config.hooks && typeof config.hooks === 'object') ? config.hooks : {};
-  const enabled = { ...DEFAULTS, ...hooksCfg };
-
-  // Run each enabled intent module, collect non-null hints
-  const hints = [];
-  for (const [key, modulePath] of Object.entries(INTENT_MODULES)) {
-    if (enabled[key] === false) continue;
-    try {
-      const detect = require(modulePath);
-      const result = detect(prompt, config, projectKey);
-      if (result) hints.push(result);
-    } catch (e) {
-      process.stderr.write(`[intent-engine] ${key}: ${e.message}\n`);
-    }
+  let intentBlock = '';
+  try {
+    intentBlock = buildIntentHintBlock(prompt, config, projectKey);
+  } catch (e) {
+    process.stderr.write(`[intent-engine] registry: ${e.message}\n`);
+    return exit();
   }
-
-  if (hints.length === 0) return exit();
+  if (!intentBlock) return exit();
 
   process.stdout.write(JSON.stringify({
-    hookSpecificOutput: { additionalSystemPrompt: hints.join('\n\n') },
+    hookSpecificOutput: { additionalSystemPrompt: intentBlock },
   }));
   exit();
 }

package/scripts/intent-registry.js

@@ -0,0 +1,59 @@
+'use strict';
+
+/**
+ * Shared intent registry for all MetaMe runtime adapters.
+ *
+ * Detection logic lives here so Claude hooks and daemon-driven runtimes
+ * (for example Codex) stay behaviorally aligned.
+ */
+
+const DEFAULTS = Object.freeze({
+  team_dispatch: true,
+  ops_assist: true,
+  task_create: true,
+  file_transfer: true,
+  memory_recall: true,
+  doc_router: true,
+});
+
+const INTENT_MODULES = Object.freeze({
+  team_dispatch: require('./hooks/intent-team-dispatch'),
+  ops_assist: require('./hooks/intent-ops-assist'),
+  task_create: require('./hooks/intent-task-create'),
+  file_transfer: require('./hooks/intent-file-transfer'),
+  memory_recall: require('./hooks/intent-memory-recall'),
+  doc_router: require('./hooks/intent-doc-router'),
+});
+
+function resolveEnabledIntents(config = {}) {
+  const hooksCfg = (config.hooks && typeof config.hooks === 'object') ? config.hooks : {};
+  return { ...DEFAULTS, ...hooksCfg };
+}
+
+function collectIntentHints(prompt, config = {}, projectKey = '') {
+  const text = String(prompt || '').trim();
+  if (!text) return [];
+
+  const enabled = resolveEnabledIntents(config);
+  const hints = [];
+  for (const [key, detect] of Object.entries(INTENT_MODULES)) {
+    if (enabled[key] === false) continue;
+    const hint = detect(text, config, projectKey);
+    if (hint) hints.push({ key, hint });
+  }
+  return hints;
+}
+
+function buildIntentHintBlock(prompt, config = {}, projectKey = '') {
+  return collectIntentHints(prompt, config, projectKey)
+    .map(item => item.hint)
+    .join('\n\n');
+}
+
+module.exports = {
+  DEFAULTS,
+  INTENT_MODULES,
+  resolveEnabledIntents,
+  collectIntentHints,
+  buildIntentHintBlock,
+};

package/scripts/memory-extract.js

@@ -346,6 +346,65 @@ async function run() {
       }
     }
 
+    // ── Codex sessions ──────────────────────────────────────────────────────
+    // Same pipeline, different source: reads ~/.codex/sessions rollout files
+    // (first 2KB only) + history.jsonl for user messages.
+    const codexSessions = sessionAnalytics.findAllUnextractedCodexSessions(3);
+    if (codexSessions.length > 0) {
+      // Pass session IDs so loadCodexHistory only parses relevant entries
+      // (history.jsonl grows unbounded; no need to load the full file)
+      const historyMap = sessionAnalytics.loadCodexHistory(codexSessions.map(cs => cs.session_id));
+      for (const cs of codexSessions) {
+        try {
+          const { skeleton, evidence } = sessionAnalytics.buildCodexInput(cs.path, historyMap);
+
+          // Skip trivial sessions with no user messages
+          if (skeleton.message_count < 1) {
+            sessionAnalytics.markCodexFactsExtracted(cs.session_id);
+            continue;
+          }
+
+          const { ok, facts, session_name } = await extractFacts(skeleton, evidence, distillEnv);
+          if (!ok) {
+            console.log(`[memory-extract] Codex ${cs.session_id.slice(0, 8)}: extraction failed, will retry later`);
+            continue;
+          }
+
+          if (facts.length > 0) {
+            const fallbackScope = `codex_${String(cs.session_id).replace(/[^a-zA-Z0-9_-]/g, '').slice(0, 24)}`;
+            const { saved, skipped, superseded, savedFacts } = memory.saveFacts(
+              cs.session_id,
+              skeleton.project || 'unknown',
+              facts,
+              { scope: skeleton.project_id || fallbackScope, source_type: 'codex' }
+            );
+            let labelsSaved = 0;
+            if (typeof memory.saveFactLabels === 'function' && Array.isArray(savedFacts) && savedFacts.length > 0) {
+              const labelRows = buildFactLabelRows(facts, savedFacts);
+              if (labelRows.length > 0) {
+                const lr = memory.saveFactLabels(labelRows);
+                labelsSaved = Number(lr && lr.saved) || 0;
+              }
+            }
+            totalSaved += saved;
+            totalSkipped += skipped;
+            const superMsg = superseded > 0 ? `, ${superseded} superseded` : '';
+            const labelMsg = labelsSaved > 0 ? `, ${labelsSaved} labels` : '';
+            console.log(`[memory-extract] Codex ${cs.session_id.slice(0, 8)} (${session_name}): ${saved} facts saved${superMsg}${labelMsg}`);
+          } else {
+            console.log(`[memory-extract] Codex ${cs.session_id.slice(0, 8)} (${session_name}): no facts extracted`);
+          }
+
+          sessionAnalytics.markCodexFactsExtracted(cs.session_id);
+          saveSessionTag(cs.session_id, session_name, facts);
+          processed++;
+        } catch (e) {
+          console.log(`[memory-extract] Codex session error: ${e.message}`);
+        }
+      }
+    }
+    // ── end Codex ────────────────────────────────────────────────────────────
+
     memory.close();
     return { sessionsProcessed: processed, factsSaved: totalSaved, factsSkipped: totalSkipped };
   } finally {

package/scripts/mentor-engine.js

@@ -54,6 +54,11 @@ function saveRuntime(runtime) {
   fs.renameSync(tmp, file);
 }
 
+function clearRuntime() {
+  saveRuntime(defaultRuntime());
+  return defaultRuntime();
+}
+
 function normalizeText(input) {
   return String(input || '').trim();
 }
@@ -394,6 +399,7 @@ module.exports = {
   gcExpiredDebts,
   detectPatterns,
   getRuntimeStatus,
+  clearRuntime,
   _private: {
     runtimeFilePath,
     loadRuntime,

package/scripts/schema.js

@@ -103,6 +103,7 @@ const SCHEMA = {
 
   // === T5: Growth (metacognition, system-managed) ===
   'growth.patterns': { tier: 'T5', type: 'array', maxItems: 3 },
+  'growth.self_reflection_patterns': { tier: 'T5', type: 'array', maxItems: 3 },
   'growth.zone_history': { tier: 'T5', type: 'array', maxItems: 10 },
   'growth.reflections_answered': { tier: 'T5', type: 'number' },
   'growth.reflections_skipped': { tier: 'T5', type: 'number' },

package/scripts/self-reflect.js

@@ -5,7 +5,8 @@
  *
  * 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.
+ * self-critique pattern into growth.self_reflection_patterns
+ * in ~/.claude_profile.yaml.
  *
  * Also distills correction signals into lessons/ SOP markdown files.
  *
@@ -27,6 +28,81 @@ const LOCK_FILE = path.join(HOME, '.metame', 'self-reflect.lock');
 const LESSONS_DIR = path.join(HOME, '.metame', 'memory', 'lessons');
 const WINDOW_DAYS = 7;
 
+function normalizeReflectionEntry(entry) {
+  if (!entry) return null;
+  if (typeof entry === 'string') {
+    const summary = entry.trim();
+    if (!summary) return null;
+    return {
+      summary,
+      detected: new Date().toISOString().slice(0, 10),
+    };
+  }
+  if (typeof entry === 'object' && typeof entry.summary === 'string' && entry.summary.trim()) {
+    return {
+      summary: entry.summary.trim(),
+      detected: entry.detected || new Date().toISOString().slice(0, 10),
+    };
+  }
+  return null;
+}
+
+function mergeReflectionEntries(entries) {
+  const merged = new Map();
+  for (const entry of entries) {
+    const normalized = normalizeReflectionEntry(entry);
+    if (!normalized) continue;
+    const existing = merged.get(normalized.summary);
+    if (!existing) {
+      merged.set(normalized.summary, normalized);
+      continue;
+    }
+
+    const existingDetected = existing.detected ? new Date(existing.detected).getTime() : 0;
+    const normalizedDetected = normalized.detected ? new Date(normalized.detected).getTime() : 0;
+    const shouldReplace =
+      normalizedDetected > 0 && (
+        existingDetected === 0
+        || normalizedDetected < existingDetected
+      );
+    if (shouldReplace) merged.set(normalized.summary, { ...existing, ...normalized });
+  }
+  return [...merged.values()];
+}
+
+function normalizeSelfReflectionPatterns(profile) {
+  if (!profile.growth) profile.growth = {};
+
+  const current = Array.isArray(profile.growth.self_reflection_patterns)
+    ? profile.growth.self_reflection_patterns
+    : [];
+  const legacy = Array.isArray(profile.growth.patterns)
+    ? profile.growth.patterns.filter(p => typeof p === 'string')
+    : [];
+
+  const normalized = mergeReflectionEntries([...current, ...legacy])
+    .slice(-3);
+
+  profile.growth.self_reflection_patterns = normalized;
+  if (Array.isArray(profile.growth.patterns)) {
+    profile.growth.patterns = profile.growth.patterns.filter(p => typeof p === 'object' && p && typeof p.summary === 'string');
+  }
+
+  return normalized;
+}
+
+function migrateLegacySelfReflectionPatterns(profile) {
+  const beforePatterns = JSON.stringify((profile.growth && profile.growth.patterns) || null);
+  const beforeReflections = JSON.stringify((profile.growth && profile.growth.self_reflection_patterns) || null);
+  const normalized = normalizeSelfReflectionPatterns(profile);
+  const afterPatterns = JSON.stringify((profile.growth && profile.growth.patterns) || null);
+  const afterReflections = JSON.stringify((profile.growth && profile.growth.self_reflection_patterns) || null);
+  return {
+    changed: beforePatterns !== afterPatterns || beforeReflections !== afterReflections,
+    normalized,
+  };
+}
+
 /**
  * Distill correction signals into reusable SOP markdown files.
  * Each run produces at most one lesson file per unique slug.
@@ -148,6 +224,22 @@ async function run() {
   }
 
   try {
+    // Persist legacy string-pattern migration even when this run produces no new reflections.
+    if (fs.existsSync(BRAIN_FILE)) {
+      try {
+        const yaml = require('js-yaml');
+        const profile = yaml.load(fs.readFileSync(BRAIN_FILE, 'utf8')) || {};
+        const migrated = migrateLegacySelfReflectionPatterns(profile);
+        if (migrated.changed) {
+          const dumped = yaml.dump(profile, { lineWidth: -1 });
+          await writeBrainFileSafe(dumped);
+          console.log('[self-reflect] Migrated legacy growth.patterns strings into growth.self_reflection_patterns.');
+        }
+      } catch (e) {
+        console.log(`[self-reflect] Legacy pattern migration failed (non-fatal): ${e.message}`);
+      }
+    }
+
     // Read signals from last WINDOW_DAYS days
     if (!fs.existsSync(SIGNAL_FILE)) {
       console.log('[self-reflect] No signal file, skipping.');
@@ -175,9 +267,9 @@ async function run() {
     try {
       const yaml = require('js-yaml');
       const profile = yaml.load(fs.readFileSync(BRAIN_FILE, 'utf8')) || {};
-      const existing = (profile.growth && profile.growth.patterns) || [];
+      const existing = migrateLegacySelfReflectionPatterns(profile).normalized;
       if (existing.length > 0) {
-        currentPatterns = `Current growth.patterns (avoid repeating):\n${existing.map(p => `- ${p}`).join('\n')}\n\n`;
+        currentPatterns = `Current growth.self_reflection_patterns (avoid repeating):\n${existing.map(p => `- ${p.summary}`).join('\n')}\n\n`;
       }
     } catch { /* non-fatal */ }
 
@@ -247,24 +339,24 @@ ${signalText}
       return;
     }
 
-    // Merge into growth.patterns (cap at 3, keep newest)
+    // Merge into growth.self_reflection_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)
+      const existing = migrateLegacySelfReflectionPatterns(profile).normalized;
+      const merged = mergeReflectionEntries([
+        ...existing,
+        ...patterns.map(summary => ({ summary, detected: new Date().toISOString().slice(0, 10) })),
+      ])
         .slice(-3);
-      profile.growth.patterns = merged;
+      profile.growth.self_reflection_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(' | ')}`);
+      console.log(`[self-reflect] ${patterns.length} pattern(s) written to growth.self_reflection_patterns: ${patterns.join(' | ')}`);
     } catch (e) {
       console.log(`[self-reflect] Failed to write profile: ${e.message}`);
     }
@@ -283,4 +375,10 @@ if (require.main === module) {
   });
 }
 
-module.exports = { run };
+module.exports = {
+  run,
+  mergeReflectionEntries,
+  normalizeReflectionEntry,
+  normalizeSelfReflectionPatterns,
+  migrateLegacySelfReflectionPatterns,
+};