metame-cli 1.5.3 → 1.5.5

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/memory-nightly-reflect.js

@@ -108,13 +108,13 @@ function writeReflectLog(record) {
  * Query hot zone facts from memory.db.
  * Returns array of plain objects.
  */
-function queryHotFacts(db) {
+function queryHotFacts(db, windowDays = WINDOW_DAYS) {
   const relationPlaceholders = EXCLUDED_RELATIONS.map(() => '?').join(', ');
   const stmt = db.prepare(`
     SELECT id, entity, relation, value, confidence, search_count, created_at
     FROM facts
     WHERE search_count >= ${MIN_SEARCH_COUNT}
-      AND created_at >= datetime('now', '-${WINDOW_DAYS} days')
+      AND created_at >= datetime('now', '-${windowDays} days')
       AND superseded_by IS NULL
       AND (conflict_status IS NULL OR conflict_status = 'OK')
       AND relation NOT IN (${relationPlaceholders})
@@ -212,10 +212,8 @@ function parseJsonFromLlm(raw) {
   try { return JSON.parse(cleaned); } catch { return null; }
 }
 
-function writeCapsuleFile(filePath, capsule, facts, today, prefix) {
-  const related = Array.isArray(capsule.related_concepts) ? capsule.related_concepts.slice(0, 8) : [];
-  const supporting = Array.isArray(capsule.supporting_facts) ? capsule.supporting_facts.slice(0, 8) : [];
-  const content = `---
+function writeCapsuleFile(filePath, markdownContent, facts, today, prefix) {
+  const frontmatter = `---
 date: ${today}
 source: nightly-reflect
 type: knowledge-capsule
@@ -223,21 +221,30 @@ entity_prefix: ${prefix}
 facts_analyzed: ${Array.isArray(facts) ? facts.length : 0}
 ---
 
-# ${capsule.title}
-
-## 核心结论
-${capsule.core_conclusion}
-
-## 适用场景
-${capsule.applicable_scenarios}
-
-## 关联概念
-${related.length > 0 ? related.map(x => `- ${x}`).join('\n') : '- (none)'}
-
-## 支撑事实
-${supporting.length > 0 ? supporting.map(x => `- ${x}`).join('\n') : '- (none)'}
 `;
-  fs.writeFileSync(filePath, content, 'utf8');
+  try {
+    fs.writeFileSync(filePath, frontmatter + markdownContent, 'utf8');
+    return true;
+  } catch (e) {
+    console.log(`[NIGHTLY-REFLECT] Warning: failed to write capsule ${filePath}: ${e.message}`);
+    return false;
+  }
+}
+
+function appendCapsuleUpdate(filePath, markdownContent, today) {
+  // Idempotency: skip if same-day update already appended
+  try {
+    const existing = fs.readFileSync(filePath, 'utf8');
+    if (existing.includes(`## 🔄 增量研判 (${today})`)) return false;
+  } catch { /* file may not be readable, proceed */ }
+  try {
+    const section = `\n\n## 🔄 增量研判 (${today})\n\n${markdownContent}\n`;
+    fs.appendFileSync(filePath, section, 'utf8');
+    return true;
+  } catch (e) {
+    console.log(`[NIGHTLY-REFLECT] Warning: failed to append capsule update ${filePath}: ${e.message}`);
+    return false;
+  }
 }
 
 /**
@@ -272,7 +279,10 @@ async function run() {
     db.exec('PRAGMA busy_timeout = 5000');
 
     const hotFacts = queryHotFacts(db);
-    console.log(`[NIGHTLY-REFLECT] Found ${hotFacts.length} hot-zone facts.`);
+    // Recent facts (last 1 day) used exclusively for incremental capsule appends,
+    // preventing the 7-day rolling window from re-distilling the same facts repeatedly.
+    const recentFacts = queryHotFacts(db, 1);
+    console.log(`[NIGHTLY-REFLECT] Found ${hotFacts.length} hot-zone facts (${recentFacts.length} from last 24h).`);
 
     if (hotFacts.length < 3) {
       console.log('[NIGHTLY-REFLECT] Insufficient hot facts (< 3), skipping distillation.');
@@ -332,6 +342,7 @@ Rules:
     } catch (e) {
       console.log(`[NIGHTLY-REFLECT] Haiku call failed: ${e.message}`);
       writeReflectLog({ status: 'error', reason: 'haiku_failed', error: e.message, facts_found: hotFacts.length });
+      releaseLock();
       return;
     }
 
@@ -340,6 +351,7 @@ Rules:
     if (!parsed || typeof parsed !== 'object') {
       console.log('[NIGHTLY-REFLECT] Failed to parse Haiku output.');
       writeReflectLog({ status: 'error', reason: 'parse_failed', facts_found: hotFacts.length });
+      releaseLock();
       return;
     }
 
@@ -377,50 +389,104 @@ Rules:
       }
 
       // 3C: knowledge capsule aggregation by entity prefix.
+      // Cold start uses full hotFacts (7 days); incremental uses recentFacts (1 day)
+      // to prevent the same facts from being re-distilled every night.
       const capsuleGroups = collectCapsuleGroups(hotFacts, 3).slice(0, 3);
       for (const group of capsuleGroups) {
-        const groupFacts = group.items.map(f => ({
+        const capsuleSlug = sanitizeSlug(group.prefix.replace(/\./g, '-'), 'capsule');
+        const capsuleFile = path.join(CAPSULES_DIR, `${capsuleSlug}-playbook.md`);
+        const playbookExists = fs.existsSync(capsuleFile);
+
+        // For incremental appends, only use facts from the last 24 hours
+        const factsForGroup = playbookExists
+          ? collectCapsuleGroups(recentFacts, 1).find(g => g.prefix === group.prefix)
+          : group;
+        // Skip append if no new facts in the last 24 hours
+        if (playbookExists && !factsForGroup) continue;
+
+        const sourceItems = factsForGroup ? factsForGroup.items : group.items;
+        const groupFacts = sourceItems.map(f => ({
           entity: f.entity,
           relation: f.relation,
           value: f.value,
           search_count: f.search_count,
         }));
-        const capsulePrompt = `你是知识胶囊生成器。请将同一主题下的事实聚合成结构化胶囊。
+        const capsulePrompt = playbookExists
+          ? `你是知识胶囊维护者。以下是该主题近期新增的原始事实，请提炼成简洁的增量段落（不超过300字），直接追加到现有手册。不要重复旧内容，不要输出大标题。
 
 entity_prefix: ${group.prefix}
-facts(json): ${JSON.stringify(groupFacts, null, 2).slice(0, 5000)}
+新增 facts(json): ${JSON.stringify(groupFacts, null, 2).slice(0, 3000)}
 
-输出 JSON：
-{
-  "title":"标题",
-  "core_conclusion":"一句核心结论",
-  "applicable_scenarios":"适用场景（1-2句）",
-  "related_concepts":["概念1","概念2"],
-  "supporting_facts":["支撑点1","支撑点2"]
-}
+输出格式（仅段落内容，Markdown 列表）：
+- **[具体要点/报错/红线]**：[原因与解法，含变量名/路径/报错原文]`
+          : `你是首席布道师与底层架构师。请将以下零散的开发者流水账，升维提炼成一本《硬核架构与避坑手册》(Playbook)。
 
-规则：
-- 只基于输入事实，不虚构
-- 每个字段简洁具体
-- 仅输出 JSON`;
+entity_prefix: ${group.prefix}
+输入事实(JSON): ${JSON.stringify(groupFacts, null, 2).slice(0, 5000)}
 
-        let capsule = null;
+【输出信仰与戒律】
+1. 绝对的业务原子性：必须写具体的变量名、报错信息、文件路径，不要写"遇到了问题解决问题"。
+2. 倒金字塔结构：致命错误、架构红线必须写在最前面的 🩸 血泪避坑指南 中。
+3. 如果输入事实中包含报错原文（如 Exception 栈），必须保留在 🔍 历史报错指纹 中。
+4. 必须使用 Markdown 格式输出，不要有任何 JSON 包装。
+5. 去除一切废话：不要用"总而言之"、"这体现了"等水文词汇，全本必须干货。
+
+请按以下 Markdown 模板输出：
+# 📕 Playbook: [你提炼的主题名称]
+
+> **胶囊摘要**：[一句话核心]
+> **覆盖实体**：${group.prefix}
+> **核心标签**：[tag1, tag2, tag3]
+
+---
+
+## 1. 🩸 血泪避坑指南 (Critical Red Lines)
+- **[问题名]**：[具体诱因与解法]
+
+## 2. 🏗️ 架构决议 (Architecture Decisions)
+- **[为什么选X不选Y]**：[理由]
+
+## 3. 🔍 历史报错指纹 (Error Fingerprints)
+- \`[报错原文]\`
+  - **诱因**：...
+  - **解法**：...
+
+## 4. 🔗 图谱扩展 (Related Concepts)
+- [相关主题或文件引用]`;
+
+        let capsuleMarkdown = null;
         try {
           const rawCapsule = await Promise.race([
             callHaiku(capsulePrompt, distillEnv, 60000),
             new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 65000)),
           ]);
-          capsule = parseJsonFromLlm(rawCapsule);
+          capsuleMarkdown = typeof rawCapsule === 'string' ? rawCapsule.trim() : null;
         } catch { /* non-fatal */ }
-        if (!capsule || !capsule.title || !capsule.core_conclusion || !capsule.applicable_scenarios) continue;
+        // Strip markdown code fences that Haiku may wrap around output
+        if (capsuleMarkdown) {
+          capsuleMarkdown = capsuleMarkdown
+            .replace(/^```(markdown)?\s*/i, '')
+            .replace(/```\s*$/i, '')
+            .trim();
+        }
+        if (!capsuleMarkdown || capsuleMarkdown.length < 50) continue;
 
-        const capsuleSlug = sanitizeSlug(group.prefix.replace(/\./g, '-'), 'capsule');
-        const capsuleFile = path.join(CAPSULES_DIR, `${capsuleSlug}-${today}.md`);
-        writeCapsuleFile(capsuleFile, capsule, group.items, today, group.prefix);
+        if (playbookExists) {
+          appendCapsuleUpdate(capsuleFile, capsuleMarkdown, today);
+        } else {
+          writeCapsuleFile(capsuleFile, capsuleMarkdown, sourceItems, today, group.prefix);
+        }
         capsulesWritten++;
 
         if (memory && typeof memory.saveFacts === 'function') {
-          const capsuleValue = stripMd(`${capsule.title}: ${capsule.core_conclusion}`).slice(0, 280);
+          const titleMatch = capsuleMarkdown.match(/^# 📕 Playbook:\s*(.+)$/m)
+            || capsuleMarkdown.match(/^## (.+)$/m);
+          const capsuleTitle = (titleMatch ? titleMatch[1].trim() : group.prefix).slice(0, 80);
+          const summaryMatch = capsuleMarkdown.match(/\*\*胶囊摘要\*\*[：:]\s*(.+)/);
+          const capsuleSummary = summaryMatch
+            ? summaryMatch[1].trim()
+            : stripMd(capsuleMarkdown.slice(0, 120));
+          const capsuleValue = `${capsuleTitle}: ${capsuleSummary}`.slice(0, 280);
           if (capsuleValue.length >= 20) {
             const saveCapsule = memory.saveFacts(`capsule-${today}-${capsuleSlug}`, '*', [{
               entity: `capsule.${group.prefix.replace(/\./g, '_')}`,

package/scripts/memory.js

@@ -99,8 +99,8 @@ function getDb() {
   }
 
   // Backward-compatible migration for old DBs without `scope`
-  try { _db.exec('ALTER TABLE sessions ADD COLUMN scope TEXT DEFAULT NULL'); } catch {}
-  try { _db.exec('CREATE INDEX IF NOT EXISTS idx_sessions_scope ON sessions(scope)'); } catch {}
+  try { _db.exec('ALTER TABLE sessions ADD COLUMN scope TEXT DEFAULT NULL'); } catch { }
+  try { _db.exec('CREATE INDEX IF NOT EXISTS idx_sessions_scope ON sessions(scope)'); } catch { }
 
 
   // ── Facts table: atomic knowledge triples ──
@@ -167,27 +167,27 @@ function getDb() {
   }
 
   // Indexes
-  try { _db.exec('CREATE INDEX IF NOT EXISTS idx_facts_entity  ON facts(entity)'); } catch {}
-  try { _db.exec('CREATE INDEX IF NOT EXISTS idx_facts_entity_relation ON facts(entity, relation)'); } catch {}
-  try { _db.exec('CREATE INDEX IF NOT EXISTS idx_facts_project ON facts(project)'); } catch {}
-  try { _db.exec('CREATE INDEX IF NOT EXISTS idx_fact_labels_label ON fact_labels(label)'); } catch {}
-  try { _db.exec('CREATE INDEX IF NOT EXISTS idx_fact_labels_domain ON fact_labels(domain)'); } catch {}
+  try { _db.exec('CREATE INDEX IF NOT EXISTS idx_facts_entity  ON facts(entity)'); } catch { }
+  try { _db.exec('CREATE INDEX IF NOT EXISTS idx_facts_entity_relation ON facts(entity, relation)'); } catch { }
+  try { _db.exec('CREATE INDEX IF NOT EXISTS idx_facts_project ON facts(project)'); } catch { }
+  try { _db.exec('CREATE INDEX IF NOT EXISTS idx_fact_labels_label ON fact_labels(label)'); } catch { }
+  try { _db.exec('CREATE INDEX IF NOT EXISTS idx_fact_labels_domain ON fact_labels(domain)'); } catch { }
 
   // Backward-compatible migration for old DBs without `scope`
-  try { _db.exec('ALTER TABLE facts ADD COLUMN scope TEXT DEFAULT NULL'); } catch {}
-  try { _db.exec('CREATE INDEX IF NOT EXISTS idx_facts_scope   ON facts(scope)'); } catch {}
+  try { _db.exec('ALTER TABLE facts ADD COLUMN scope TEXT DEFAULT NULL'); } catch { }
+  try { _db.exec('CREATE INDEX IF NOT EXISTS idx_facts_scope   ON facts(scope)'); } catch { }
 
   // Search frequency tracking: counts how many times a fact appeared in search results.
   // This is a RELEVANCE PROXY, not a usefulness score — "searched" ≠ "actually helpful".
   // Renamed from recall_count (was ambiguous). Migration copies existing data forward.
-  try { _db.exec('ALTER TABLE facts ADD COLUMN recall_count INTEGER DEFAULT 0'); } catch {}
-  try { _db.exec('ALTER TABLE facts ADD COLUMN search_count INTEGER DEFAULT 0'); } catch {}
-  try { _db.exec('ALTER TABLE facts ADD COLUMN last_searched_at TEXT'); } catch {}
+  try { _db.exec('ALTER TABLE facts ADD COLUMN recall_count INTEGER DEFAULT 0'); } catch { }
+  try { _db.exec('ALTER TABLE facts ADD COLUMN search_count INTEGER DEFAULT 0'); } catch { }
+  try { _db.exec('ALTER TABLE facts ADD COLUMN last_searched_at TEXT'); } catch { }
   // One-time migration: copy recall_count → search_count for existing rows
-  try { _db.exec('UPDATE facts SET search_count = recall_count WHERE recall_count > 0 AND search_count = 0'); } catch {}
+  try { _db.exec('UPDATE facts SET search_count = recall_count WHERE recall_count > 0 AND search_count = 0'); } catch { }
 
   // conflict_status: 'OK' (default) | 'CONFLICT' — set by _detectConflict for non-stateful relations
-  try { _db.exec("ALTER TABLE facts ADD COLUMN conflict_status TEXT NOT NULL DEFAULT 'OK'"); } catch {}
+  try { _db.exec("ALTER TABLE facts ADD COLUMN conflict_status TEXT NOT NULL DEFAULT 'OK'"); } catch { }
 
   return _db;
 }
@@ -317,8 +317,10 @@ function saveFacts(sessionId, project, facts, { scope = null } = {}) {
       insert.run(id, f.entity, f.relation, f.value.slice(0, 300),
         f.confidence || 'medium', sourceType, sessionId, normalizedProject, normalizedScope, tags);
       batchDedup.add(dedupKey);
-      savedFacts.push({ id, entity: f.entity, relation: f.relation, value: f.value,
-        project: normalizedProject, scope: normalizedScope, tags: f.tags || [], created_at: new Date().toISOString() });
+      savedFacts.push({
+        id, entity: f.entity, relation: f.relation, value: f.value,
+        project: normalizedProject, scope: normalizedScope, tags: f.tags || [], created_at: new Date().toISOString()
+      });
       saved++;
 
       // For stateful relations, mark older active facts with same entity::relation as superseded
@@ -440,7 +442,7 @@ function _trackSearch(ids) {
 }
 
 const SUPERSEDE_LOG = path.join(os.homedir(), '.metame', 'memory_supersede_log.jsonl');
-const CONFLICT_LOG  = path.join(os.homedir(), '.metame', 'memory_conflict_log.jsonl');
+const CONFLICT_LOG = path.join(os.homedir(), '.metame', 'memory_conflict_log.jsonl');
 
 /**
  * Append supersede operations to audit log (append-only, never mutated).
@@ -767,6 +769,42 @@ function searchFacts(query, { limit = 5, project = null, scope = null } = {}) {
       }
     } catch { /* fact_labels table may not exist yet */ }
   }
+  // Entity path expansion: supplement with entity hierarchy matches per query term.
+  // Handles multi-word queries like "daemon dispatch" that won't match dotted entity paths
+  // (e.g. "MetaMe.daemon.dispatch.cross-bot") via LIKE '%daemon dispatch%'.
+  if (likeResults.length < limit) {
+    const terms = query.trim().split(/\s+/).filter(t => t.length >= 3);
+    if (terms.length > 0) {
+      try {
+        const likeIds = new Set(likeResults.map(r => r.id));
+        const entityOrClauses = terms.map(() => `entity LIKE ?`).join(' OR ');
+        const entityParams = terms.map(t => `%${t}%`);
+        let entityExpSql = `SELECT id, entity, relation, value, confidence, project, scope, tags, created_at
+          FROM facts WHERE (${entityOrClauses})
+            AND superseded_by IS NULL
+            AND (conflict_status IS NULL OR conflict_status NOT IN ('ARCHIVED', 'CONFLICT'))`;
+        if (scope && project) {
+          entityExpSql += ` AND ((scope = ? OR scope = '*') OR (scope IS NULL AND (project = ? OR project = '*')))`;
+          entityParams.push(scope, project);
+        } else if (scope) {
+          entityExpSql += ` AND (scope = ? OR scope = '*')`;
+          entityParams.push(scope);
+        } else if (project) {
+          entityExpSql += ` AND (project = ? OR project = '*')`;
+          entityParams.push(project);
+        }
+        entityExpSql += ` ORDER BY created_at DESC LIMIT ?`;
+        entityParams.push(limit);
+        const entityRows = db.prepare(entityExpSql).all(...entityParams);
+        for (const row of entityRows) {
+          if (!likeIds.has(row.id) && likeResults.length < limit) {
+            likeIds.add(row.id);
+            likeResults.push(row);
+          }
+        }
+      } catch { /* entity expansion failed */ }
+    }
+  }
   if (likeResults.length > 0) _trackSearch(likeResults.map(r => r.id));
   return likeResults;
 }

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,
+};