metame-cli 1.5.1 → 1.5.2

package/index.js

@@ -806,73 +806,10 @@ try {
   // Non-fatal
 }
 
-// ---------------------------------------------------------
-// 4.6 REFLECTION PROMPT (Phase C — conditional, NOT static)
-// ---------------------------------------------------------
-// Only inject when trigger conditions are met at startup.
-// This ensures reflections don't fire every session.
-let reflectionLine = '';
-try {
-  if (isKnownUser && _brainDoc) {
-    const refDoc = _brainDoc;
-
-    // Check quiet mode
-    const quietUntil = refDoc.growth && refDoc.growth.quiet_until;
-    const isQuietForRef = quietUntil && new Date(quietUntil).getTime() > Date.now();
-
-    if (!isQuietForRef) {
-      const distillCount = (refDoc.evolution && refDoc.evolution.distill_count) || 0;
-      const zoneHistory = (refDoc.growth && refDoc.growth.zone_history) || [];
-
-      // Trigger 1: Every 7th session
-      const trigger7th = distillCount > 0 && distillCount % 7 === 0;
-
-      // Trigger 2: Three consecutive comfort-zone sessions
-      const lastThree = zoneHistory.slice(-3);
-      const triggerComfort = lastThree.length === 3 && lastThree.every(z => z === 'C');
-
-      // Trigger 3: Persistent goal drift (2+ drifted in last 3 sessions)
-      let triggerDrift = false;
-      let driftDeclaredFocus = null;
-      try {
-        const sessionLogFile = path.join(METAME_DIR, 'session_log.yaml');
-        if (fs.existsSync(sessionLogFile)) {
-          const driftLog = yaml.load(fs.readFileSync(sessionLogFile, 'utf8'));
-          if (driftLog && Array.isArray(driftLog.sessions)) {
-            const recentSessions = driftLog.sessions.slice(-3);
-            const driftCount = recentSessions.filter(s =>
-              s.goal_alignment === 'drifted' || s.goal_alignment === 'partial'
-            ).length;
-            if (driftCount >= 2 && recentSessions.length >= 2) {
-              driftDeclaredFocus = refDoc.status?.focus || refDoc.context?.focus;
-              if (driftDeclaredFocus) triggerDrift = true;
-            }
-          }
-        }
-      } catch { /* non-fatal */ }
-
-      if (triggerDrift || triggerComfort || trigger7th) {
-        let hint = '';
-        if (triggerDrift) {
-          hint = `最近几个session的方向和"${driftDeclaredFocus}"有偏差。请在对话开始时温和地问：${icon("mirror")} 是方向有意调整了，还是不小心偏了？`;
-        } else if (triggerComfort) {
-          hint = `连续几次都在熟悉领域。如果用户在session结束时自然停顿，可以温和地问：${icon("mirror")} 准备好探索拉伸区了吗？`;
-        } else {
-          hint = '这是第' + distillCount + `次session。如果session自然结束，可以附加一句：${icon("mirror")} 一个词形容这次session的感受？`;
-        }
-        const timing = triggerDrift ? '在对话开始时就问一次' : '只在session即将结束时说一次';
-        reflectionLine = `\n[MetaMe reflection: ${hint} ${timing}。如果用户没回应就不要追问。]\n`;
-      }
-    }
-  }
-} catch {
-  // Non-fatal
-}
-
 // Project-level CLAUDE.md: KERNEL has moved to global ~/.claude/CLAUDE.md.
-// Only inject dynamic per-session observations (mirror / reflection).
+// Only inject dynamic per-session observations (mirror).
 // If nothing dynamic, write the cleaned file with no METAME block at all.
-const dynamicContent = mirrorLine + reflectionLine;
+const dynamicContent = mirrorLine;
 const newContent = dynamicContent.trim()
   ? METAME_START + '\n' + dynamicContent + METAME_END + '\n' + fileContent
   : fileContent;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.5.1",
+    "version": "1.5.2",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {
@@ -17,7 +17,7 @@
         "test": "node --test scripts/*.test.js",
         "test:daemon-status": "node --test scripts/daemon-restart-status.test.js",
         "start": "node index.js",
-        "sync:plugin": "cp scripts/platform.js scripts/schema.js scripts/pending-traits.js scripts/signal-capture.js scripts/distill.js scripts/daemon.js scripts/daemon-agent-commands.js scripts/daemon-session-commands.js scripts/daemon-admin-commands.js scripts/daemon-exec-commands.js scripts/daemon-ops-commands.js scripts/daemon-session-store.js scripts/daemon-checkpoints.js scripts/daemon-bridges.js scripts/daemon-file-browser.js scripts/daemon-runtime-lifecycle.js scripts/daemon-notify.js scripts/daemon-claude-engine.js scripts/daemon-engine-runtime.js scripts/daemon-command-router.js scripts/daemon-user-acl.js scripts/daemon-agent-tools.js scripts/daemon-task-scheduler.js scripts/daemon-task-envelope.js scripts/task-board.js scripts/telegram-adapter.js scripts/feishu-adapter.js scripts/daemon-default.yaml scripts/providers.js scripts/utils.js scripts/usage-classifier.js scripts/resolve-yaml.js scripts/memory.js scripts/memory-write.js scripts/memory-extract.js scripts/memory-search.js scripts/memory-gc.js scripts/memory-nightly-reflect.js scripts/memory-index.js scripts/qmd-client.js scripts/session-summarize.js scripts/session-analytics.js scripts/mentor-engine.js scripts/skill-evolution.js scripts/skill-changelog.js scripts/agent-layer.js scripts/check-macos-control-capabilities.sh plugin/scripts/ && echo 'Plugin scripts synced'",
+        "sync:plugin": "cp scripts/platform.js scripts/schema.js scripts/pending-traits.js scripts/signal-capture.js scripts/distill.js scripts/daemon.js scripts/daemon-agent-commands.js scripts/daemon-session-commands.js scripts/daemon-admin-commands.js scripts/daemon-exec-commands.js scripts/daemon-ops-commands.js scripts/daemon-session-store.js scripts/daemon-checkpoints.js scripts/daemon-bridges.js scripts/daemon-file-browser.js scripts/daemon-runtime-lifecycle.js scripts/daemon-notify.js scripts/daemon-claude-engine.js scripts/daemon-engine-runtime.js scripts/daemon-command-router.js scripts/daemon-user-acl.js scripts/daemon-agent-tools.js scripts/daemon-task-scheduler.js scripts/daemon-task-envelope.js scripts/task-board.js scripts/telegram-adapter.js scripts/feishu-adapter.js scripts/daemon-default.yaml scripts/providers.js scripts/utils.js scripts/usage-classifier.js scripts/resolve-yaml.js scripts/memory.js scripts/memory-write.js scripts/memory-extract.js scripts/memory-search.js scripts/memory-gc.js scripts/memory-nightly-reflect.js scripts/memory-index.js scripts/qmd-client.js scripts/session-summarize.js scripts/session-analytics.js scripts/mentor-engine.js scripts/skill-evolution.js scripts/skill-changelog.js scripts/agent-layer.js scripts/self-reflect.js scripts/check-macos-control-capabilities.sh plugin/scripts/ && echo 'Plugin scripts synced'",
         "sync:readme": "node scripts/sync-readme.js",
         "restart:daemon": "node index.js stop 2>/dev/null; sleep 1; node index.js start 2>/dev/null || echo '鈿狅笍  Daemon not running or restart failed'",
         "precommit": "npm run sync:plugin && npm run restart:daemon"

package/scripts/bin/dispatch_to

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * dispatch_to [--new] <project_key> "<prompt>"
+ * dispatch_to [--new] [--from <project_key>] <project_key> "<prompt>"
  * Tries Unix socket / Named Pipe first (low-latency), falls back to pending.jsonl.
  */
 'use strict';
@@ -13,10 +13,18 @@ const { socketPath } = require('../platform');
 
 const args = process.argv.slice(2);
 const newSession = args[0] === '--new' ? (args.shift(), true) : false;
+
+// --from <project_key>: identifies the calling agent for callback routing
+let fromKey = '_claude_session';
+const fromIdx = args.indexOf('--from');
+if (fromIdx !== -1 && args[fromIdx + 1]) {
+  fromKey = args.splice(fromIdx, 2)[1];
+}
+
 const [target, ...rest] = args;
 const prompt = rest.join(' ').replace(/^["']|["']$/g, '');
 if (!target || !prompt) {
-  console.error('Usage: dispatch_to [--new] <project_key> "<prompt>"');
+  console.error('Usage: dispatch_to [--new] [--from <project_key>] <project_key> "<prompt>"');
   process.exit(1);
 }
 
@@ -41,10 +49,43 @@ function getDispatchSecret() {
 
 const ts = new Date().toISOString();
 const secret = getDispatchSecret();
-const sigPayload = JSON.stringify({ target, prompt, ts });
+
+// Auto-inject shared context: now/shared.md + target's _latest.md
+function buildEnrichedPrompt(rawPrompt) {
+  const nowFile = path.join(METAME_DIR, 'memory', 'now', 'shared.md');
+  const agentFile = path.join(METAME_DIR, 'memory', 'agents', `${target}_latest.md`);
+  let ctx = '';
+  try { if (fs.existsSync(nowFile)) ctx += `[共享进度 now.md]\n${fs.readFileSync(nowFile, 'utf8').trim()}\n\n`; } catch {}
+  try { if (fs.existsSync(agentFile)) ctx += `[${target} 上次产出]\n${fs.readFileSync(agentFile, 'utf8').trim()}\n\n`; } catch {}
+  // Push model: inject unread inbox messages and immediately archive them
+  try {
+    const inboxDir = path.join(METAME_DIR, 'memory', 'inbox', target);
+    const readDir = path.join(inboxDir, 'read');
+    const files = fs.readdirSync(inboxDir).filter(f => f.endsWith('.md')).sort();
+    if (files.length > 0) {
+      ctx += `[📬 Agent Inbox — ${files.length} 条未读消息]\n`;
+      fs.mkdirSync(readDir, { recursive: true });
+      for (const f of files) {
+        const filePath = path.join(inboxDir, f);
+        ctx += fs.readFileSync(filePath, 'utf8').trim() + '\n---\n';
+        fs.renameSync(filePath, path.join(readDir, f));
+      }
+      ctx += '\n';
+    }
+  } catch {}
+  return ctx ? `${ctx}---\n${rawPrompt}` : rawPrompt;
+}
+
+const enrichedPrompt = buildEnrichedPrompt(prompt);
+const sigPayload = JSON.stringify({ target, prompt: enrichedPrompt, 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 };
+// Set callback: true when dispatched by another agent (not a user session)
+const callback = fromKey !== '_claude_session';
+const msg = { target, prompt: enrichedPrompt, from: fromKey, new_session: newSession, created_at: ts, ts, sig, ...(callback && { callback: true }) };
+
+// Ensure target's inbox exists — lazy init, safe for new users and new agents
+fs.mkdirSync(path.join(METAME_DIR, 'memory', 'inbox', target, 'read'), { recursive: true });
 
 function fallbackToFile() {
   fs.mkdirSync(DISPATCH_DIR, { recursive: true });

package/scripts/daemon-command-router.js

@@ -678,6 +678,7 @@ function createCommandRouter(deps) {
       const followUp = await askClaude(bot, chatId, combined, config, readOnly);
       if (followUp && followUp.error === 'Stopped by user') break;
     }
+
   }
 
   return { handleCommand };

package/scripts/daemon-task-scheduler.js

@@ -338,7 +338,7 @@ function createTaskScheduler(deps) {
 
     if (!checkBudget(config, state)) {
       log('WARN', `Budget exceeded, skipping task: ${task.name}`);
-      return { success: false, error: 'budget_exceeded', output: '' };
+      return { success: false, error: 'budget_exceeded', output: '', skipped: true };
     }
 
     // Precondition gate: run a cheap shell check before burning tokens
@@ -583,7 +583,7 @@ function createTaskScheduler(deps) {
     const state = loadState();
     if (!checkBudget(config, state)) {
       log('WARN', `Budget exceeded, skipping workflow: ${task.name}`);
-      return { success: false, error: 'budget_exceeded', output: '' };
+      return { success: false, error: 'budget_exceeded', output: '', skipped: true };
     }
     // precheck.pass is guaranteed true here — executeTask() already returns early when false
     const steps = task.steps || [];
@@ -793,6 +793,14 @@ function createTaskScheduler(deps) {
           Promise.resolve(executeTask(task, config))
             .then((result) => {
               runningTasks.delete(task.name);
+              // Budget exceeded: back off until next day instead of retrying every interval
+              if (result.error === 'budget_exceeded') {
+                const tomorrow = new Date();
+                tomorrow.setDate(tomorrow.getDate() + 1);
+                tomorrow.setHours(0, 5, 0, 0); // 00:05 next day
+                nextRun[task.name] = tomorrow.getTime();
+                return;
+              }
               if (task.notify && notifyFn && !result.skipped) {
                 const proj = task._project || null;
                 if (result.success) {

package/scripts/daemon.js

@@ -847,6 +847,25 @@ function dispatchTask(targetProject, message, config, replyFn, streamOptions = n
     if (replyFn && outStr.trim().length > 2) {
       replyFn(outStr);
     } else if (!replyFn && fullMsg.callback && fullMsg.from && config) {
+      // Write result to sender's inbox before dispatching callback
+      try {
+        const inboxDir = path.join(os.homedir(), '.metame', 'memory', 'inbox', fullMsg.from);
+        fs.mkdirSync(inboxDir, { recursive: true });
+        const tsStr = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 15);
+        const subject = `callback_${(fullMsg.payload.title || fullMsg.id || 'task').replace(/\s+/g, '_').slice(0, 30)}`;
+        const inboxFile = path.join(inboxDir, `${tsStr}_${targetProject}_${subject}.md`);
+        const body = [
+          `FROM: ${targetProject}`,
+          `TO: ${fullMsg.from}`,
+          `TS: ${new Date().toISOString()}`,
+          `SUBJECT: ${subject}`,
+          '',
+          outStr.trim().slice(0, 2000),
+        ].join('\n');
+        fs.writeFileSync(inboxFile, body, 'utf8');
+      } catch (e) {
+        log('WARN', `callback inbox write failed: ${e.message}`);
+      }
       dispatchTask(fullMsg.from, {
         from: targetProject,
         type: 'callback',
@@ -1808,6 +1827,16 @@ function acquireDaemonLock() {
               if (attempt < maxAttempts - 1) continue;
               return false;
             }
+            // Parent is dead — re-read lock before deleting: another daemon (e.g. LaunchAgent-
+            // spawned) may have acquired it in the window between parent exit and us waking up.
+            try {
+              const reread = JSON.parse(fs.readFileSync(LOCK_FILE, 'utf8') || '{}');
+              const newOwner = parseInt(reread.pid, 10);
+              if (newOwner && newOwner !== ownerPid && newOwner !== process.pid && isPidAlive(newOwner)) {
+                log('WARN', `Lock acquired by PID ${newOwner} during handoff — yielding`);
+                return false;
+              }
+            } catch { /* lock already gone — proceed to create */ }
             try { fs.unlinkSync(LOCK_FILE); } catch { /* ignore */ }
             continue;
           }
@@ -1828,7 +1857,13 @@ function releaseDaemonLock() {
     if (daemonLockFd !== null) fs.closeSync(daemonLockFd);
   } catch { /* ignore */ }
   daemonLockFd = null;
-  try { if (fs.existsSync(LOCK_FILE)) fs.unlinkSync(LOCK_FILE); } catch { /* ignore */ }
+  // Only delete the lock file if we still own it — avoids wiping a successor daemon's lock.
+  try {
+    if (fs.existsSync(LOCK_FILE)) {
+      const meta = JSON.parse(fs.readFileSync(LOCK_FILE, 'utf8') || '{}');
+      if (parseInt(meta.pid, 10) === process.pid) fs.unlinkSync(LOCK_FILE);
+    }
+  } catch { /* ignore */ }
 }
 
 // ---------------------------------------------------------

package/scripts/distill.js

@@ -1370,12 +1370,86 @@ If no clear patterns found: respond with exactly NO_PATTERNS`;
   }
 }
 
+// ---------------------------------------------------------
+// SESSION REFLECTION — fill reflection word for sessions that lack one
+// ---------------------------------------------------------
+
+/**
+ * For each session in session_log.yaml that has no `reflection` field,
+ * call Haiku once (batch) to generate a 1-4 char Chinese word capturing the feel.
+ * Runs after every distill — no-op if all sessions already have reflection.
+ */
+async function fillSessionReflections() {
+  const yaml = require('js-yaml');
+  if (!fs.existsSync(SESSION_LOG_FILE)) return;
+
+  let log;
+  try {
+    log = yaml.load(fs.readFileSync(SESSION_LOG_FILE, 'utf8')) || { sessions: [] };
+  } catch { return; }
+  if (!Array.isArray(log.sessions)) return;
+
+  const pending = log.sessions.filter(s => !s.reflection);
+  if (pending.length === 0) return;
+
+  const sessionLines = pending.map((s, i) => {
+    const parts = [];
+    if (s.topics && s.topics.length) parts.push(`topics: ${s.topics.join(', ')}`);
+    if (s.zone) parts.push(`zone: ${s.zone}`);
+    if (s.cognitive_load) parts.push(`load: ${s.cognitive_load}`);
+    if (s.goal_alignment) parts.push(`goal: ${s.goal_alignment}`);
+    if (s.friction && s.friction.length) parts.push(`friction: ${s.friction.join(', ')}`);
+    if (s.session_outcome) parts.push(`outcome: ${s.session_outcome}`);
+    return `${i + 1}. [${s.ts || '?'}] ${parts.join(' | ')}`;
+  }).join('\n');
+
+  const prompt = `You are a session reflection assistant. For each session below, generate ONE Chinese word (1-4 characters) that honestly captures the overall feel or experience of that session.
+
+SESSIONS:
+${sessionLines}
+
+OUTPUT FORMAT — respond with ONLY a YAML code block:
+\`\`\`yaml
+reflections:
+  - "专注"
+  - "艰难"
+\`\`\`
+
+One word per session, in order. Chinese only. Be honest and precise.`;
+
+  try {
+    const result = await callHaiku(prompt, distillEnv, 20000);
+    if (!result) return;
+
+    const yamlMatch = result.match(/```yaml\n([\s\S]*?)```/) || result.match(/```\n([\s\S]*?)```/);
+    if (!yamlMatch) return;
+
+    const parsed = yaml.load(yamlMatch[1].trim());
+    if (!parsed || !Array.isArray(parsed.reflections)) return;
+
+    let written = 0;
+    for (let i = 0; i < pending.length && i < parsed.reflections.length; i++) {
+      const word = String(parsed.reflections[i] || '').trim().slice(0, 8);
+      if (word) { pending[i].reflection = word; written++; }
+    }
+
+    if (written > 0) {
+      const tmp = SESSION_LOG_FILE + '.tmp';
+      fs.writeFileSync(tmp, yaml.dump(log, { lineWidth: -1 }), 'utf8');
+      fs.renameSync(tmp, SESSION_LOG_FILE);
+    }
+  } catch {
+    // Non-fatal
+  }
+}
+
 // Export for use in index.js
 module.exports = {
   distill,
   writeSessionLog,
   bootstrapSessionLog,
   detectPatterns,
+  fillSessionReflections,
   _private: {
     mergeCompetenceMap,
     normalizeCompetenceLevel,
@@ -1401,6 +1475,9 @@ if (require.main === module) {
       writeSessionLog(result.behavior, result.signalCount || 0, result.skeleton || null, result.sessionSummary || null);
     }
 
+    // Fill reflection words for sessions that don't have one yet
+    await fillSessionReflections();
+
     // Run pattern detection (only triggers every 5th distill)
     if (!bootstrapped) await detectPatterns();
 

package/scripts/publish-public.sh

@@ -0,0 +1,85 @@
+#!/usr/bin/env bash
+# Sync sanitized code from private repo to the public MetaMe repo.
+#
+# Usage:
+#   ./scripts/publish-public.sh              # generate to ../MetaMe-public
+#   ./scripts/publish-public.sh --push       # generate + push to public repo
+#
+# Workflow:
+#   - You develop in MetaMe-private (this repo), push to origin as usual
+#   - Run this script when you want to update the public mirror
+#   - Private modules (listed in .private-modules) get replaced with stubs
+
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+PRIVATE_LIST="$REPO_ROOT/.private-modules"
+OUT_DIR="$REPO_ROOT/../MetaMe-public"
+PUBLIC_REMOTE="git@github.com:Yaron9/MetaMe.git"
+
+DO_PUSH=false
+for arg in "$@"; do
+  case "$arg" in
+    --push) DO_PUSH=true ;;
+  esac
+done
+
+if [ ! -f "$PRIVATE_LIST" ]; then
+  echo "Error: .private-modules not found"
+  exit 1
+fi
+
+PRIVATE_FILES=()
+while IFS= read -r line; do
+  line="${line%%#*}"
+  line="${line// /}"
+  [ -z "$line" ] && continue
+  PRIVATE_FILES+=("$line")
+done < "$PRIVATE_LIST"
+
+echo "==> Generating public release to: $OUT_DIR"
+echo "    Stripping ${#PRIVATE_FILES[@]} private modules"
+
+rm -rf "$OUT_DIR"
+mkdir -p "$OUT_DIR"
+
+git -C "$REPO_ROOT" archive HEAD | tar -x -C "$OUT_DIR"
+
+# Strip .private-modules itself from public release
+rm -f "$OUT_DIR/.private-modules"
+
+for pattern in "${PRIVATE_FILES[@]}"; do
+  for file in $OUT_DIR/$pattern; do
+    [ -f "$file" ] || continue
+    rel="${file#$OUT_DIR/}"
+    basename=$(basename "$file" .js)
+    cat > "$file" << STUB
+// This module is part of MetaMe's proprietary core.
+// See https://github.com/Yaron9/MetaMe for the open-source components.
+//
+// Module: ${basename}
+// License: Business Source License (BSL 1.1)
+//
+// For licensing inquiries: github.com/Yaron9/MetaMe/issues
+
+module.exports = {};
+STUB
+    echo "    [stub] $rel"
+  done
+done
+
+echo "==> Done. ${#PRIVATE_FILES[@]} modules stubbed."
+
+if [ "$DO_PUSH" = true ]; then
+  cd "$OUT_DIR"
+  if [ ! -d .git ]; then
+    git init -b main
+    git remote add origin "$PUBLIC_REMOTE"
+  fi
+  git add -A
+  COMMIT_MSG="sync: $(git -C "$REPO_ROOT" log -1 --format='%h %s')"
+  git commit -m "$COMMIT_MSG" --allow-empty
+  echo "==> Pushing to public repo..."
+  git push -u origin main --force
+  echo "==> Public repo updated."
+fi

package/scripts/self-reflect.js

@@ -0,0 +1,286 @@
+#!/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');
+        fs.writeSync(lockFd, process.pid.toString());
+        fs.closeSync(lockFd);
+      } catch {
+        // Another process acquired the lock, or write failed — ensure fd is closed
+        try { if (lockFd !== undefined) fs.closeSync(lockFd); } catch { /* ignore */ }
+        return;
+      }
+    } 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 };