metame-cli 1.4.10 → 1.4.12

package/README.md

@@ -172,40 +172,26 @@ Task fails → skill-scout finds a skill → installs → retries → succeeds
 
 ## Quick Start
 
-### Install
-
 ```bash
-# One-line install (includes Node.js + Claude Code if missing)
-curl -fsSL https://raw.githubusercontent.com/Yaron9/MetaMe/main/install.sh | bash
-
-# Or if you already have Claude Code
-npm install -g metame-cli
-```
-
-### First Run
-
-```bash
-metame
+npm install -g metame-cli && metame
 ```
 
-On first launch, MetaMe runs a brief cognitive interview to build your profile. After that, it's automatic.
+**3 minutes to full setup:**
 
-### Enable Mobile Access
+| Step | Command | What happens |
+|------|---------|-------------|
+| 1. Install & profile | `metame` | First run: cognitive interview → builds `~/.claude_profile.yaml` |
+| 2. Connect phone | Follow the setup wizard | Bot token + app credentials → `~/.metame/daemon.yaml` |
+| 3. Start daemon | `metame start` | Background daemon launches, bot goes online |
+| 4. Auto-start | `metame daemon install-launchd` | Survives reboot + crash recovery |
 
-```bash
-metame daemon init    # Creates config with setup guide
-metame start          # Launches background daemon
-```
+**Create your first Agent:**
 
-Edit `~/.metame/daemon.yaml` with your Telegram bot token or Feishu app credentials, then:
+1. Create a group chat in Telegram/Feishu, add your bot
+2. Send `/agent bind <name>` in the group (e.g. `/agent bind personal`)
+3. Pick a working directory from the buttons, or type a path directly — non-existent directories are created automatically → done
 
-```bash
-metame daemon install-launchd   # Auto-start on boot + crash recovery
-```
-
-Done. Open Telegram, message your bot.
-
-> **First message?** New chats aren't whitelisted yet. The bot will reply with a one-step setup command — just send `/agent bind personal ~/` and you're in.
+> Want more Agents? Repeat: new group → add bot → `/agent bind <name>`. Each group = independent AI workspace.
 
 ---
 
@@ -234,7 +220,7 @@ The easiest way. Open any Telegram/Feishu group and use the `/agent` wizard:
 
 | Command | What it does |
 |---------|-------------|
-| `/agent new` | Step-by-step wizard: pick a directory → name the agent → describe its role. MetaMe writes the role into `CLAUDE.md` automatically. |
+| `/agent new` | Step-by-step wizard: pick a directory → name the agent → describe its role. MetaMe writes the role into `CLAUDE.md` automatically. You can also type a path directly in chat — if it doesn't exist, MetaMe creates it for you. |
 | `/agent bind <name> [dir]` | Quick bind: register this group as a named agent, optionally set working directory. |
 | `/agent list` | Show all configured agents. |
 | `/agent edit` | Update the current agent's role description (rewrites its `CLAUDE.md` section). |
@@ -245,14 +231,17 @@ Example flow:
 You:     /agent new
 Bot:     Please select a working directory:
          📁 ~/AGI   📁 ~/projects   📁 ~/Desktop
-You:     ~/AGI/MyProject
-Bot:     What should we name this agent?
+You:     ~/AGI/MyProject/NewDir
+Bot:     ✅ 已新建目录：~/AGI/MyProject/NewDir
+         What should we name this agent?
 You:     小美
 Bot:     Describe 小美's role and responsibilities:
 You:     Personal assistant. Manages my calendar, drafts messages, and tracks todos.
 Bot:     ✅ Agent「小美」created. CLAUDE.md updated with role definition.
 ```
 
+You can tap a button to pick an existing directory, or type any path directly in chat. If the path doesn't exist, it's created automatically. All entry points (`/agent new` wizard and `/agent bind`) validate that the directory is real before saving.
+
 ### From config file (for power users)
 
 ```yaml

package/index.js

@@ -390,10 +390,14 @@ You are entering **Calibration Mode**. You are not a chatbot; you are a Psycholo
 - Announce: "Link Established. Profile calibrated."
 - Then proceed to **Phase 2** below.
 
-**3. SETUP WIZARD (Phase 2 — Optional):**
+**3. SETUP WIZARD (Phase 2 — Mobile Access):**
 
 After writing the profile, ask: *"Want to set up mobile access so you can reach me from your phone? (Telegram / Feishu / Skip)"*
 
+**Step A: Create Bot & Connect Private Chat (必做)**
+
+This step connects the bot to the user's PRIVATE chat — this is the admin channel.
+
 - If **Telegram:**
   1. Tell user to open Telegram, search @BotFather, send /newbot, create a bot, copy the token.
   2. Ask user to paste the bot token.
@@ -408,7 +412,7 @@ After writing the profile, ask: *"Want to set up mobile access so you can reach
      **⚠️ 重要：** 在「事件订阅」页面，必须开启「接收消息 im.message.receive_v1」事件。然后在该事件的配置中，勾选「获取群组中所有消息」（否则 bot 在群聊中只能收到 @它 的消息，无法接收普通群消息）。
   2. Ask user to paste App ID and App Secret.
   3. Write \`app_id\` and \`app_secret\` into \`~/.metame/daemon.yaml\` under \`feishu:\` section, set \`enabled: true\`.
-  4. Tell user: "Now open Feishu and send any message to your new bot, then tell me you're done."
+  4. Tell user: "Now open Feishu and send any message to your new bot (private chat), then tell me you're done."
   5. After user confirms, auto-fetch the chat ID:
      \`\`\`bash
      TOKEN=$(curl -s -X POST https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal -H "Content-Type: application/json" -d '{"app_id":"<APP_ID>","app_secret":"<APP_SECRET>"}' | jq -r '.tenant_access_token')
@@ -419,22 +423,16 @@ After writing the profile, ask: *"Want to set up mobile access so you can reach
 
 - If **Skip:** Say "No problem. You can run \`metame daemon init\` anytime to set this up later." Then begin normal work.
 
-**After setup, teach the user about Agent Dispatch:**
-
-Tell the user: *"You now have multiple AI agents that can collaborate. Here's how to send messages between them:"*
-
-- **From mobile (Telegram/Feishu):** Each chat group is bound to a specific agent (project). To send a message to another agent, use:
-  \`/dispatch <project_key> <message>\`
-  Example: \`/dispatch desktop 帮我检查一下桌面端的日志\`
-
-- **From Claude Code terminal:** Use the dispatch command:
-  \`~/.metame/bin/dispatch_to <project_key> "message"\`
+**Step B: Create Your First Agent (引导用户建立第一个 Agent)**
 
-- **Natural language shortcut:** Just say "告诉小美…" or "让老马…" — the AI will automatically route the message to the right agent.
+After bot is connected, explain the Agent concept and guide the user to create their first one:
 
-- **Available agents** are configured in \`~/.metame/daemon.yaml\` under \`projects:\`. Each project maps to an agent with its own working directory and Claude session.
+Tell the user: *"Now let's create your first AI Agent. Each Agent is an independent AI workspace bound to a specific project folder and chat group."*
 
-- **To add a new agent:** Send \`/agent bind <name> <working_directory>\` from any chat. This creates a new project and binds it to that chat.
+1. Tell user to create a new group chat in Telegram/Feishu, add the bot to the group, and name it (e.g. "Personal Assistant" or "My Project").
+2. Tell user to send \`/agent bind <name>\` in that group (e.g. \`/agent bind personal\`). This will show a directory picker — user taps to select the working directory.
+3. Once bound, that group becomes a dedicated Agent channel — messages there go to that Agent's Claude session.
+4. Tell user: *"Want to create more Agents? Just repeat: create a group → add bot → send /agent bind <name>. Each group becomes an independent Agent."*
 
 **4. EVOLUTION MECHANISM (Manual Sync):**
    *   **PHILOSOPHY:** You respect the User's flow. You do NOT interrupt.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.4.10",
+    "version": "1.4.12",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {
@@ -33,4 +33,4 @@
     "engines": {
         "node": ">=22.5"
     }
-}
+}

package/scripts/daemon.js

@@ -28,6 +28,7 @@ const BRAIN_FILE = path.join(HOME, '.claude_profile.yaml');
 const DISPATCH_DIR = path.join(METAME_DIR, 'dispatch');
 const DISPATCH_LOG = path.join(DISPATCH_DIR, 'dispatch-log.jsonl');
 const SOCK_PATH = path.join(METAME_DIR, 'daemon.sock');
+const DISPATCH_SECRET_FILE = path.join(METAME_DIR, '.dispatch_secret');
 
 // Resolve claude binary path (daemon may not inherit user's full PATH)
 const CLAUDE_BIN = (() => {
@@ -78,7 +79,7 @@ function routeAgent(prompt, config) {
 }
 
 const yaml = require('./resolve-yaml');
-const { parseInterval, formatRelativeTime, createPathMap } = require('./utils');
+const { parseInterval, formatRelativeTime, createPathMap, writeBrainFileSafe } = require('./utils');
 if (!yaml) {
   console.error('Cannot find js-yaml module. Ensure metame-cli is installed.');
   process.exit(1);
@@ -149,6 +150,21 @@ function backupConfig() {
   try { fs.copyFileSync(CONFIG_FILE, bak); } catch { }
 }
 
+/**
+ * Atomically write cfg object to CONFIG_FILE.
+ * Writes to a .tmp file first, then fs.renameSync (POSIX atomic).
+ * Process crash leaves .tmp on disk, never a partially-written CONFIG_FILE.
+ */
+function writeConfigSafe(cfg) {
+  const tmp = CONFIG_FILE + '.tmp.' + process.pid;
+  try {
+    fs.writeFileSync(tmp, yaml.dump(cfg, { lineWidth: -1 }), 'utf8');
+    fs.renameSync(tmp, CONFIG_FILE);
+  } finally {
+    try { fs.unlinkSync(tmp); } catch { } // no-op if rename succeeded
+  }
+}
+
 function restoreConfig() {
   const bak = CONFIG_FILE + '.bak';
   if (!fs.existsSync(bak)) return false;
@@ -171,7 +187,7 @@ function restoreConfig() {
         );
       }
     }
-    fs.writeFileSync(CONFIG_FILE, yaml.dump(bakCfg, { lineWidth: -1 }), 'utf8');
+    writeConfigSafe(bakCfg);
     config = loadConfig();
     return true;
   } catch {
@@ -797,11 +813,59 @@ function spawnSessionSummaries() {
  * Physiological heartbeat: zero-token awareness check.
  * Runs every tick unconditionally.
  */
+/**
+ * Load or generate the dispatch HMAC secret.
+ */
+function getDispatchSecret() {
+  try {
+    if (fs.existsSync(DISPATCH_SECRET_FILE)) {
+      return fs.readFileSync(DISPATCH_SECRET_FILE, 'utf8').trim();
+    }
+  } catch { /* fall through to generate */ }
+  // Auto-generate and persist
+  const secret = require('crypto').randomBytes(32).toString('hex');
+  try {
+    fs.writeFileSync(DISPATCH_SECRET_FILE, secret, { mode: 0o600 });
+  } catch (e) {
+    log('WARN', `[dispatch] Could not write secret file: ${e.message}`);
+  }
+  return secret;
+}
+
+/**
+ * Compute HMAC-SHA256 signature for a dispatch item.
+ */
+function signDispatch(target, prompt, ts) {
+  const secret = getDispatchSecret();
+  const payload = JSON.stringify({ target, prompt, ts });
+  return require('crypto').createHmac('sha256', secret).update(payload).digest('hex');
+}
+
+/**
+ * Verify dispatch signature. Returns true if valid or if sig is absent and
+ * legacy mode (no secret file exists yet). Logs + returns false on mismatch.
+ */
+function verifyDispatchSig(item) {
+  // If no secret file exists, accept unsigned messages (migration grace period)
+  if (!fs.existsSync(DISPATCH_SECRET_FILE)) return true;
+  if (!item.sig || !item.ts) {
+    log('WARN', `[dispatch] Unsigned message from "${item.from}" — dropped (sig/ts missing)`);
+    return false;
+  }
+  const expected = signDispatch(item.target, item.prompt, item.ts);
+  if (item.sig !== expected) {
+    log('WARN', `[dispatch] Signature mismatch from "${item.from}" → "${item.target}" — dropped`);
+    return false;
+  }
+  return true;
+}
+
 /**
  * Handle a single dispatch message (from socket or pending.jsonl fallback).
  */
 function handleDispatchItem(item, config) {
   if (!item.target || !item.prompt) return;
+  if (!verifyDispatchSig(item)) return;
   if (!(config && config.projects && config.projects[item.target])) {
     log('WARN', `dispatch: unknown target "${item.target}"`);
     return;
@@ -918,6 +982,31 @@ function physiologicalHeartbeat(config) {
     log('WARN', `Pending dispatch drain failed: ${e.message}`);
   }
 
+  // 2a. Check distill budget alerts — notify user once then clear
+  const DISTILL_ALERTS = path.join(METAME_DIR, 'distill_alerts.jsonl');
+  try {
+    if (fs.existsSync(DISTILL_ALERTS)) {
+      const raw = fs.readFileSync(DISTILL_ALERTS, 'utf8').trim();
+      if (raw) {
+        const alerts = raw.split('\n').filter(Boolean)
+          .map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+        const budgetAlerts = alerts.filter(a => a.type === 'budget_exceeded');
+        if (budgetAlerts.length > 0) {
+          const latest = budgetAlerts[budgetAlerts.length - 1];
+          const msg = `⚠️ 认知系统告警：Profile 大小超出预算 (${latest.tokens} tokens > ${latest.budget})，本次更新已被丢弃。建议 /quiet 或手动清理 ~/.claude_profile.yaml 中的 evolution 字段。`;
+          // Notify all active chats (or fallback to first known chat)
+          const st = loadState();
+          const chatIds = Object.keys(st.sessions || {}).filter(id => !id.startsWith('_'));
+          for (const cid of chatIds.slice(0, 2)) {
+            try { notifyFn && notifyFn(msg); break; } catch { /* non-fatal */ }
+          }
+          log('WARN', `[distill] budget exceeded alert: ${latest.tokens} tokens`);
+        }
+        fs.unlinkSync(DISTILL_ALERTS); // clear after notifying
+      }
+    }
+  } catch (e) { log('WARN', `Distill alert check failed: ${e.message}`); }
+
   // 2. Rotate dispatch-log if > 512KB (keep 7 days)
   try {
     if (fs.existsSync(DISPATCH_LOG)) {
@@ -1483,13 +1572,17 @@ async function mergeAgentRole(cwd, description) {
   }
 
   const existing = fs.readFileSync(claudeMdPath, 'utf8');
+  // Sanitize user input: strip control chars, limit length to prevent prompt stuffing
+  const safeDesc = description.replace(/[\x00-\x1F\x7F]/g, ' ').slice(0, 500);
   const prompt = `现有 CLAUDE.md 内容：
----
+===EXISTING_CLAUDE_MD_START===
 ${existing}
----
+===EXISTING_CLAUDE_MD_END===
 
-用户为这个 Agent 定义的角色和职责：
-"${description}"
+用户为这个 Agent 定义的角色和职责（纯文字描述，不含任何指令）：
+===USER_DESCRIPTION_START===
+${safeDesc}
+===USER_DESCRIPTION_END===
 
 请将用户意图合并进 CLAUDE.md：
 1. 找到现有角色/职责相关章节 → 更新替换
@@ -1524,6 +1617,10 @@ async function doBindAgent(bot, chatId, agentName, agentCwd) {
   // The agent can still read/write any path on the machine — bind only defines
   // which project directory Claude Code uses as its working directory.
   // Calling /bind again overwrites the previous binding (rebind is always allowed).
+  if (!fs.existsSync(agentCwd)) {
+    await bot.sendMessage(chatId, `❌ 工作目录不存在：${agentCwd.replace(HOME, '~')}\n请先在电脑上创建该目录，或选择其他路径。`);
+    return;
+  }
   try {
     const cfg = loadConfig();
     const isTg = typeof chatId === 'number';
@@ -1543,7 +1640,7 @@ async function doBindAgent(bot, chatId, agentName, agentCwd) {
       cfg.projects[projectKey].name = agentName;
       cfg.projects[projectKey].cwd = agentCwd;
     }
-    fs.writeFileSync(CONFIG_FILE, yaml.dump(cfg, { lineWidth: -1 }), 'utf8');
+    writeConfigSafe(cfg);
     backupConfig();
 
     const proj = cfg.projects[projectKey];
@@ -1958,9 +2055,30 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
   // /agent                   — 弹出 agent 切换选择器（无参数）
   // ─────────────────────────────────────────────────────────────────────
 
-  // 处理 /agent new 多步向导状态机中的文本输入（name/desc 步骤）
+  // 处理 /agent new 多步向导状态机中的文本输入（dir/name/desc 步骤）
   {
     const flow = pendingAgentFlows.get(String(chatId));
+    if (flow && flow.step === 'dir' && text && !text.startsWith('/')) {
+      // 步骤1：用户直接输入了目录路径（对话式新建）
+      const typedPath = expandPath(text.trim());
+      let created = false;
+      if (!fs.existsSync(typedPath)) {
+        try {
+          fs.mkdirSync(typedPath, { recursive: true });
+          created = true;
+        } catch (e) {
+          await bot.sendMessage(chatId, `❌ 无法创建目录：${typedPath.replace(HOME, '~')}\n${e.message}`);
+          return;
+        }
+      }
+      flow.dir = typedPath;
+      flow.step = 'name';
+      pendingAgentFlows.set(String(chatId), flow);
+      const displayPath = typedPath.replace(HOME, '~');
+      const label = created ? `✅ 已新建目录：${displayPath}` : `✓ 已选择目录：${displayPath}`;
+      await bot.sendMessage(chatId, `${label}\n\n步骤2/3：给这个 Agent 起个名字？`);
+      return;
+    }
     if (flow && flow.step === 'name' && text && !text.startsWith('/')) {
       // 步骤2: 用户回复了 Agent 名称
       flow.name = text.trim();
@@ -2034,7 +2152,12 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
         await sendDirPicker(bot, chatId, 'bind', `为「${bindName}」选择工作目录:`);
         return;
       }
-      await doBindAgent(bot, chatId, bindName, expandPath(bindCwd));
+      const resolvedBindCwd = expandPath(bindCwd);
+      if (!fs.existsSync(resolvedBindCwd)) {
+        await bot.sendMessage(chatId, `❌ 目录不存在：${resolvedBindCwd.replace(HOME, '~')}\n请检查路径或选择其他目录。`);
+        return;
+      }
+      await doBindAgent(bot, chatId, bindName, resolvedBindCwd);
       return;
     }
 
@@ -2167,11 +2290,23 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
       await bot.sendMessage(chatId, '❌ 没有待完成的 /agent new，请重新发送 /agent new');
       return;
     }
+    let dirCreated = false;
+    if (!fs.existsSync(dirPath)) {
+      try {
+        fs.mkdirSync(dirPath, { recursive: true });
+        dirCreated = true;
+      } catch (e) {
+        await bot.sendMessage(chatId, `❌ 无法创建目录：${dirPath.replace(HOME, '~')}\n${e.message}`);
+        await sendBrowse(bot, chatId, 'agent-new', HOME, '步骤1/3：选择这个 Agent 的工作目录');
+        return;
+      }
+    }
     flow.dir = dirPath;
     flow.step = 'name';
     pendingAgentFlows.set(String(chatId), flow);
     const displayPath = dirPath.replace(HOME, '~');
-    await bot.sendMessage(chatId, `✓ 已选择目录：${displayPath}\n\n步骤2/3：给这个 Agent 起个名字？`);
+    const dirLabel = dirCreated ? `✅ 已新建目录：${displayPath}` : `✓ 已选择目录：${displayPath}`;
+    await bot.sendMessage(chatId, `${dirLabel}\n\n步骤2/3：给这个 Agent 起个名字？`);
     return;
   }
 
@@ -2919,7 +3054,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
       const doc = yaml.load(fs.readFileSync(BRAIN_FILE, 'utf8')) || {};
       if (!doc.growth) doc.growth = {};
       doc.growth.quiet_until = new Date(Date.now() + 48 * 60 * 60 * 1000).toISOString();
-      fs.writeFileSync(BRAIN_FILE, yaml.dump(doc, { lineWidth: -1 }), 'utf8');
+      await writeBrainFileSafe(yaml.dump(doc, { lineWidth: -1 }), BRAIN_FILE);
       await bot.sendMessage(chatId, 'Mirror & reflections silenced for 48h.');
     } catch (e) { await bot.sendMessage(chatId, `Error: ${e.message}`); }
     return;
@@ -2954,7 +3089,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
       const cfg = yaml.load(fs.readFileSync(CONFIG_FILE, 'utf8')) || {};
       if (!cfg.daemon) cfg.daemon = {};
       cfg.daemon.model = 'opus';
-      fs.writeFileSync(CONFIG_FILE, yaml.dump(cfg, { lineWidth: -1 }), 'utf8');
+      writeConfigSafe(cfg);
       config = loadConfig();
       await bot.sendMessage(chatId, '✅ 模型已重置为 opus');
     } catch (e) {
@@ -3053,7 +3188,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
       const cfg = yaml.load(fs.readFileSync(CONFIG_FILE, 'utf8')) || {};
       if (!cfg.daemon) cfg.daemon = {};
       cfg.daemon.model = modelName;
-      fs.writeFileSync(CONFIG_FILE, yaml.dump(cfg, { lineWidth: -1 }), 'utf8');
+      writeConfigSafe(cfg);
       config = loadConfig();
       await bot.sendMessage(chatId, `✅ 模型已切换: ${currentModel} → ${modelName}`);
     } catch (e) {
@@ -4491,7 +4626,7 @@ async function askClaude(bot, chatId, prompt, config, readOnly = false) {
         const cfg = yaml.load(fs.readFileSync(CONFIG_FILE, 'utf8')) || {};
         if (!cfg.daemon) cfg.daemon = {};
         cfg.daemon.model = 'opus';
-        fs.writeFileSync(CONFIG_FILE, yaml.dump(cfg, { lineWidth: -1 }), 'utf8');
+        writeConfigSafe(cfg);
         config = loadConfig();
         await bot.sendMessage(chatId, `⚠️ ${activeProvCheck}/${model} 疑似失败，已回退到 anthropic/opus\n输出: ${output.slice(0, 150)}`);
       } catch (fbErr) {
@@ -4587,7 +4722,7 @@ async function askClaude(bot, chatId, prompt, config, readOnly = false) {
           const cfg = yaml.load(fs.readFileSync(CONFIG_FILE, 'utf8')) || {};
           if (!cfg.daemon) cfg.daemon = {};
           cfg.daemon.model = 'opus';
-          fs.writeFileSync(CONFIG_FILE, yaml.dump(cfg, { lineWidth: -1 }), 'utf8');
+          writeConfigSafe(cfg);
           config = loadConfig();
           await bot.sendMessage(chatId, `⚠️ ${activeProv}/${model} 失败，已回退到 anthropic/opus\n原因: ${errMsg.slice(0, 100)}`);
         } catch (fallbackErr) {
@@ -4626,7 +4761,7 @@ async function startFeishuBridge(config, executeTaskByName) {
       const isBindCmd = trimmedText && (trimmedText.startsWith('/bind') || trimmedText.startsWith('/agent bind') || trimmedText.startsWith('/agent new'));
       if (!allowedIds.includes(chatId) && !isBindCmd) {
         log('WARN', `Feishu: rejected message from ${chatId}`);
-        (bot.sendMarkdown ? bot.sendMarkdown(chatId, `⚠️ **此会话未授权**\n\n复制下方命令发送即可注册：\n\`\`\`\n/agent bind personal\n\`\`\``) : bot.sendMessage(chatId, `⚠️ 此会话未授权。\n\n复制下方命令发送即可注册：\n/agent bind personal`)).catch(() => {});
+        (bot.sendMarkdown ? bot.sendMarkdown(chatId, `⚠️ 此会话未授权\n\n复制发送以下命令注册：\n\n/agent bind personal`) : bot.sendMessage(chatId, `⚠️ 此会话未授权\n\n复制发送以下命令注册：\n\n/agent bind personal`)).catch(() => {});
         return;
       }
 
@@ -4885,6 +5020,64 @@ async function main() {
   // Start heartbeat scheduler
   let heartbeatTimer = startHeartbeat(config, notifyFn);
 
+  // Adapter modules that support require.cache invalidation on file change
+  const ADAPTER_MODULES = ['feishu-adapter', 'telegram-adapter', 'providers', 'skill-evolution'];
+  // Track last known mtime for each adapter file (populated after bridge startup)
+  const _adapterMtimes = new Map();
+  function _readAdapterMtimes() {
+    for (const mod of ADAPTER_MODULES) {
+      const fullPath = path.join(__dirname, `${mod}.js`);
+      try { _adapterMtimes.set(fullPath, fs.statSync(fullPath).mtimeMs); } catch { /* file may not exist */ }
+    }
+  }
+
+  // Reload adapters whose files changed on disk (stop→clear cache→restart bridges)
+  async function reloadAdapters() {
+    const changed = [];
+    for (const mod of ADAPTER_MODULES) {
+      const fullPath = path.join(__dirname, `${mod}.js`);
+      try {
+        const mtime = fs.statSync(fullPath).mtimeMs;
+        if (_adapterMtimes.get(fullPath) !== mtime) {
+          changed.push({ mod, fullPath });
+          _adapterMtimes.set(fullPath, mtime);
+        }
+      } catch { /* ignore */ }
+    }
+    if (changed.length === 0) return { reloaded: [] };
+    log('INFO', `[reloadAdapters] changed files: ${changed.map(c => c.mod).join(', ')}`);
+    const bridgeAdapters = new Set(changed.map(c => c.mod).filter(m => m === 'feishu-adapter' || m === 'telegram-adapter'));
+    // Stop bridges before clearing cache to avoid duplicate listeners
+    if (bridgeAdapters.has('feishu-adapter') && feishuBridge) {
+      try { feishuBridge.stop(); } catch { /* ignore */ }
+      feishuBridge = null;
+      _dispatchBridgeRef = null;
+    }
+    if (bridgeAdapters.has('telegram-adapter') && telegramBridge) {
+      try { telegramBridge.stop(); } catch { /* ignore */ }
+      telegramBridge = null;
+    }
+    // Clear require.cache for changed modules
+    for (const { fullPath } of changed) {
+      try { delete require.cache[require.resolve(fullPath)]; } catch { /* ignore */ }
+    }
+    // Restart bridges
+    if (bridgeAdapters.has('telegram-adapter')) {
+      telegramBridge = await startTelegramBridge(config, executeTaskByName).catch(e => {
+        log('ERROR', `[reloadAdapters] Telegram restart failed: ${e.message}`);
+        return null;
+      });
+    }
+    if (bridgeAdapters.has('feishu-adapter')) {
+      feishuBridge = await startFeishuBridge(config, executeTaskByName).catch(e => {
+        log('ERROR', `[reloadAdapters] Feishu restart failed: ${e.message}`);
+        return null;
+      });
+      if (feishuBridge) _dispatchBridgeRef = feishuBridge;
+    }
+    return { reloaded: changed.map(c => c.mod) };
+  }
+
   // Hot reload: re-read config and restart heartbeat scheduler
   function reloadConfig() {
     const newConfig = loadConfig();
@@ -4895,6 +5088,12 @@ async function main() {
     heartbeatTimer = startHeartbeat(config, notifyFn);
     const { general, project } = getAllTasks(config);
     const totalCount = general.length + project.length;
+    // Also check for adapter file changes (non-daemon.js modules)
+    reloadAdapters().then(r => {
+      if (r.reloaded.length > 0) {
+        log('INFO', `[reloadAdapters] Reloaded: ${r.reloaded.join(', ')}`);
+      }
+    }).catch(e => log('WARN', `[reloadAdapters] Error: ${e.message}`));
     log('INFO', `Config reloaded: ${totalCount} tasks (${project.length} in projects)`);
     return { success: true, tasks: totalCount };
   }
@@ -4956,6 +5155,7 @@ async function main() {
   telegramBridge = await startTelegramBridge(config, executeTaskByName);
   feishuBridge = await startFeishuBridge(config, executeTaskByName);
   if (feishuBridge) _dispatchBridgeRef = feishuBridge; // store bridge, not bot, so .bot stays live after reconnects
+  _readAdapterMtimes(); // Baseline mtimes for hot-reload detection
 
   // Notify once on startup (single message, no duplicates)
   await sleep(1500); // Let polling settle

package/scripts/distill.js

@@ -20,13 +20,16 @@ const BRAIN_FILE = path.join(HOME, '.claude_profile.yaml');
 const LOCK_FILE = path.join(HOME, '.metame', 'distill.lock');
 
 const { hasKey, isLocked, getTier, getWritableKeysForPrompt, estimateTokens, TOKEN_BUDGET } = require('./schema');
-const { loadPending, savePending, upsertPending, getPromotable, removePromoted } = require('./pending-traits');
+const { loadPending, savePending, upsertPending, getPromotable, removePromoted, expireStale } = require('./pending-traits');
+const { writeBrainFileSafe } = require('./utils');
 
 // Session analytics — local skeleton extraction (zero API cost)
 let sessionAnalytics = null;
 try {
   sessionAnalytics = require('./session-analytics');
-} catch { /* session-analytics.js not available — graceful fallback */ }
+} catch (e) {
+  console.log(`[distill] session-analytics unavailable: ${e.message} — behavior extraction disabled`);
+}
 
 // Provider env for distillation (cheap relay for background tasks)
 let distillEnv = {};
@@ -115,7 +118,9 @@ async function distill() {
           // For long sessions, extract pivot points
           sessionSummary = sessionAnalytics.summarizeSession(skeleton, latest.path);
         }
-      } catch { /* non-fatal */ }
+      } catch (e) {
+        console.log(`[distill] session context extraction failed: ${e.message}`);
+      }
     }
 
     // 4. Read current profile
@@ -169,9 +174,9 @@ async function distill() {
       budgetForMessages = availableForContent;
     }
 
-    // Format signals: tag metacognitive signals so Haiku treats them differently
+    // Format signals: tag metacognitive and correction signals so Haiku treats them differently
     const formatSignal = (s, i) => {
-      const tag = s.type === 'metacognitive' ? ' [META]' : '';
+      const tag = s.type === 'metacognitive' ? ' [META]' : s.type === 'correction' ? ' [CORRECTION]' : '';
       return `${i + 1}. "${s.text}"${tag}`;
     };
 
@@ -215,6 +220,7 @@ BIAS PREVENTION:
 - Single observation = STATE, not TRAIT. T3 cognition needs 3+ observations.
 - L1 Surface → needs 5+, L2 Behavior → needs 3, L3 Self-declaration → direct write.
 - Contradiction with existing value → do NOT output (needs accumulation).
+- EXCEPTION: [CORRECTION] signals are explicit user corrections — they CAN and SHOULD overwrite contradicting existing values directly, with _confidence: high. The user is teaching us we were wrong.
 
 BEHAVIORAL ANALYSIS — _behavior block (always output, use null if insufficient signal):
   decision_pattern: premature_closure | exploratory | iterative | null
@@ -302,6 +308,7 @@ Do NOT repeat existing unchanged values.`;
 
       // Strategic merge: tier-aware upsert with pending traits
       const pendingTraits = loadPending();
+      expireStale(pendingTraits); // remove observations not seen for >30 days
       const confidenceMap = updates._confidence || {};
       const sourceMap = updates._source || {};
       const merged = strategicMerge(profile, filtered, lockedKeys, pendingTraits, confidenceMap, sourceMap);
@@ -343,12 +350,17 @@ Do NOT repeat existing unchanged values.`;
         tokens = estimateTokens(restored);
       }
       if (tokens > TOKEN_BUDGET) {
-        // Step 3: Reject write entirely, keep previous version
+        // Step 3: Reject write entirely — emit alert so daemon can notify user
+        const alertFile = path.join(HOME, '.metame', 'distill_alerts.jsonl');
+        try {
+          const alert = { ts: new Date().toISOString(), type: 'budget_exceeded', tokens, budget: TOKEN_BUDGET };
+          fs.appendFileSync(alertFile, JSON.stringify(alert) + '\n', 'utf8');
+        } catch { /* non-fatal */ }
         cleanup();
         return { updated: false, behavior, signalCount: signals.length, summary: `Profile too large (${tokens} tokens > ${TOKEN_BUDGET}). Write rejected to prevent bloat.` };
       }
 
-      fs.writeFileSync(BRAIN_FILE, restored, 'utf8');
+      await writeBrainFileSafe(restored, BRAIN_FILE);
 
       // Mark session as analyzed after successful distill
       if (skeleton && sessionAnalytics) {

package/scripts/memory-extract.js

@@ -181,8 +181,8 @@ async function run() {
   let sessionAnalytics;
   try {
     sessionAnalytics = require('./session-analytics');
-  } catch {
-    console.log('[memory-extract] session-analytics not available, exiting.');
+  } catch (e) {
+    console.log(`[memory-extract] session-analytics unavailable: ${e.message} — memory extraction disabled`);
     return { sessionsProcessed: 0, factsSaved: 0, factsSkipped: 0 };
   }
 
@@ -222,14 +222,15 @@ async function run() {
         const { facts, session_name } = await extractFacts(skeleton, null, distillEnv);
 
         if (facts.length > 0) {
-          const { saved, skipped } = memory.saveFacts(
+          const { saved, skipped, superseded } = memory.saveFacts(
             skeleton.session_id,
             skeleton.project || 'unknown',
             facts
           );
           totalSaved += saved;
           totalSkipped += skipped;
-          console.log(`[memory-extract] Session ${skeleton.session_id.slice(0, 8)}: ${saved} facts saved, ${skipped} skipped`);
+          const superMsg = superseded > 0 ? `, ${superseded} superseded` : '';
+          console.log(`[memory-extract] Session ${skeleton.session_id.slice(0, 8)}: ${saved} facts saved, ${skipped} skipped${superMsg}`);
         } else {
           console.log(`[memory-extract] Session ${skeleton.session_id.slice(0, 8)} (${session_name}): no facts extracted`);
         }

package/scripts/memory.js

@@ -144,6 +144,15 @@ function getDb() {
   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_project ON facts(project)'); } 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 {}
+  // 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 {}
+
   return _db;
 }
 
@@ -177,16 +186,20 @@ function saveSession({ sessionId, project, summary, keywords = '', mood = '', to
   return { ok: true, id: sessionId };
 }
 
+// Relations with "current state" semantics: new value replaces old.
+// Historical relations (tech_decision, bug_lesson, arch_convention, project_milestone) keep all versions.
+const STATEFUL_RELATIONS = new Set(['user_pref', 'config_fact', 'config_change', 'workflow_rule']);
+
 /**
  * Save atomic facts extracted from a session.
  *
  * @param {string} sessionId - Source session ID
  * @param {string} project   - Project key ('metame', 'desktop', '*' for global)
  * @param {Array}  facts     - Array of { entity, relation, value, confidence, tags }
- * @returns {{ saved: number, skipped: number }}
+ * @returns {{ saved: number, skipped: number, superseded: number }}
  */
 function saveFacts(sessionId, project, facts) {
-  if (!Array.isArray(facts) || facts.length === 0) return { saved: 0, skipped: 0 };
+  if (!Array.isArray(facts) || facts.length === 0) return { saved: 0, skipped: 0, superseded: 0 };
   const db = getDb();
 
   // Load existing facts for dedup check
@@ -200,8 +213,14 @@ function saveFacts(sessionId, project, facts) {
     ON CONFLICT(id) DO NOTHING
   `);
 
+  const supersede = db.prepare(`
+    UPDATE facts SET superseded_by = ?, updated_at = datetime('now')
+    WHERE entity = ? AND relation = ? AND id != ? AND superseded_by IS NULL
+  `);
+
   let saved = 0;
   let skipped = 0;
+  let superseded = 0;
   const savedFacts = [];
 
   for (const f of facts) {
@@ -225,6 +244,24 @@ function saveFacts(sessionId, project, facts) {
       savedFacts.push({ id, entity: f.entity, relation: f.relation, value: f.value,
         project: project === '*' ? '*' : project, tags: f.tags || [], created_at: new Date().toISOString() });
       saved++;
+
+      // For stateful relations, mark older active facts with same entity::relation as superseded
+      if (STATEFUL_RELATIONS.has(f.relation)) {
+        // Fetch the IDs being superseded before running the update (for audit log)
+        const db2 = getDb();
+        const toSupersede = db2.prepare(
+          'SELECT id, value FROM facts WHERE entity = ? AND relation = ? AND id != ? AND superseded_by IS NULL'
+        ).all(f.entity, f.relation, id);
+
+        const result = supersede.run(id, f.entity, f.relation, id);
+        const changes = result.changes || 0;
+        superseded += changes;
+
+        // Audit log: append to ~/.metame/memory_supersede_log.jsonl (never mutates, only appends)
+        if (changes > 0) {
+          _logSupersede(toSupersede, id, f.entity, f.relation, f.value, sessionId);
+        }
+      }
     } catch { skipped++; }
   }
 
@@ -235,7 +272,48 @@ function saveFacts(sessionId, project, facts) {
     if (qmdClient) qmdClient.upsertFacts(savedFacts);
   }
 
-  return { saved, skipped };
+  return { saved, skipped, superseded };
+}
+
+/**
+ * Increment search_count and last_searched_at for a list of fact IDs.
+ * Semantics: "this fact appeared in search results" — NOT "this fact was useful".
+ * High search_count = frequently retrieved. Low/zero = candidate for pruning.
+ * Non-fatal; called after each successful search.
+ */
+function _trackSearch(ids) {
+  if (!ids || ids.length === 0) return;
+  try {
+    const db = getDb();
+    const placeholders = ids.map(() => '?').join(',');
+    db.prepare(
+      `UPDATE facts SET search_count = search_count + 1, last_searched_at = datetime('now')
+       WHERE id IN (${placeholders})`
+    ).run(...ids);
+  } catch { /* non-fatal */ }
+}
+
+const SUPERSEDE_LOG = path.join(os.homedir(), '.metame', 'memory_supersede_log.jsonl');
+
+/**
+ * Append supersede operations to audit log (append-only, never mutated).
+ * Each line: { ts, new_id, new_value_prefix, entity, relation, superseded: [{id, value_prefix}], session_id }
+ * Use this to investigate accidental overwrites or replay if needed.
+ */
+function _logSupersede(oldFacts, newId, entity, relation, newValue, sessionId) {
+  if (!oldFacts || oldFacts.length === 0) return;
+  try {
+    const entry = {
+      ts: new Date().toISOString(),
+      entity,
+      relation,
+      new_id: newId,
+      new_value: newValue.slice(0, 80),
+      session_id: sessionId,
+      superseded: oldFacts.map(f => ({ id: f.id, value: f.value.slice(0, 80) })),
+    };
+    fs.appendFileSync(SUPERSEDE_LOG, JSON.stringify(entry) + '\n', 'utf8');
+  } catch { /* non-fatal */ }
 }
 
 /**
@@ -272,7 +350,10 @@ async function searchFactsAsync(query, { limit = 5, project = null } = {}) {
         const idOrder = new Map(ids.map((id, i) => [id, i]));
         rows.sort((a, b) => (idOrder.get(a.id) ?? 999) - (idOrder.get(b.id) ?? 999));
 
-        if (rows.length > 0) return rows.slice(0, limit);
+        if (rows.length > 0) {
+          _trackSearch(rows.map(r => r.id));
+          return rows.slice(0, limit);
+        }
       }
     } catch { /* QMD failed, fall through to FTS5 */ }
   }
@@ -317,7 +398,10 @@ function searchFacts(query, { limit = 5, project = null } = {}) {
       params = [sanitized, limit];
     }
     const ftsResults = db.prepare(sql).all(...params);
-    if (ftsResults.length > 0) return ftsResults;
+    if (ftsResults.length > 0) {
+      _trackSearch(ftsResults.map(r => r.id));
+      return ftsResults;
+    }
   } catch { /* FTS error, fall through */ }
 
   // LIKE fallback
@@ -331,9 +415,11 @@ function searchFacts(query, { limit = 5, project = null } = {}) {
        FROM facts WHERE (entity LIKE ? OR value LIKE ? OR tags LIKE ?)
        AND superseded_by IS NULL
        ORDER BY created_at DESC LIMIT ?`;
-  return project
+  const likeResults = project
     ? db.prepare(likeSql).all(like, like, like, project, limit)
     : db.prepare(likeSql).all(like, like, like, limit);
+  if (likeResults.length > 0) _trackSearch(likeResults.map(r => r.id));
+  return likeResults;
 }
 
 /**

package/scripts/pending-traits.js

@@ -90,13 +90,26 @@ function upsertPending(pending, key, value, confidence, sourceQuote) {
 }
 
 /**
- * Get traits ready for promotion (count >= threshold OR confidence === 'high').
+ * Get traits ready for promotion.
+ * high confidence → always promote immediately.
+ * normal confidence → time-weighted count must reach threshold.
+ *   effective_count = count * max(0.3, 1 - age_days/60)
+ *   So recent observations count fully; 30-day-old observations count 50%;
+ *   60-day-old observations count at 30% floor (not zero — prevents complete stall).
  * Returns array of { key, value, source_quote }
  */
 function getPromotable(pending) {
   const ready = [];
+  const now = Date.now();
   for (const [key, meta] of Object.entries(pending)) {
-    if (meta.count >= PROMOTION_THRESHOLD || meta.confidence === 'high') {
+    if (meta.confidence === 'high') {
+      ready.push({ key, value: meta.value, source_quote: meta.source_quote });
+      continue;
+    }
+    const ageDays = Math.floor((now - new Date(meta.last_seen).getTime()) / (1000 * 60 * 60 * 24));
+    const ageWeight = Math.max(0.3, 1 - ageDays / 60);
+    const effectiveCount = meta.count * ageWeight;
+    if (effectiveCount >= PROMOTION_THRESHOLD) {
       ready.push({ key, value: meta.value, source_quote: meta.source_quote });
     }
   }

package/scripts/self-reflect.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+
+/**
+ * self-reflect.js — Weekly 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.
+ *
+ * Heartbeat: weekly, require_idle, non-blocking.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { callHaiku, buildDistillEnv } = require('./providers');
+
+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 WINDOW_DAYS = 7;
+
+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);
+      lockFd = fs.openSync(LOCK_FILE, 'wx');
+      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),
+        new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 65000)),
+      ]);
+    } 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;
+    }
+
+    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 });
+      fs.writeFileSync(BRAIN_FILE, dumped, 'utf8');
+      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 };

package/scripts/skill-evolution.js

@@ -286,6 +286,49 @@ function checkHotEvolution(signal) {
   }
 
   saveEvolutionQueue(yaml, queue);
+
+  // Rule 4: Track insight outcomes (success/failure per skill)
+  if (signal.skills_invoked && signal.skills_invoked.length > 0) {
+    const isSuccess = signal.outcome === 'success' && !signal.error && !signal.has_tool_failure;
+    const isFail = !isSuccess && (signal.error || signal.has_tool_failure ||
+      (signal.prompt && complaintRe.test(signal.prompt)));
+    if (isSuccess || isFail) {
+      for (const sk of signal.skills_invoked) {
+        const skillDir = findSkillDir(sk);
+        if (skillDir) trackInsightOutcome(skillDir, isSuccess);
+      }
+    }
+  }
+}
+
+/**
+ * Update insight outcome stats in evolution.json for a skill.
+ * Tracks success_count, fail_count, last_applied_at per insight text.
+ */
+function trackInsightOutcome(skillDir, isSuccess) {
+  const evoPath = path.join(skillDir, 'evolution.json');
+  let data = {};
+  try { data = JSON.parse(fs.readFileSync(evoPath, 'utf8')); } catch { return; }
+
+  if (!data.insights_stats) data.insights_stats = {};
+  const now = new Date().toISOString();
+  const allInsights = [
+    ...(data.preferences || []),
+    ...(data.fixes || []),
+    ...(data.contexts || []),
+  ];
+
+  for (const insight of allInsights) {
+    if (!data.insights_stats[insight]) {
+      data.insights_stats[insight] = { success_count: 0, fail_count: 0, last_applied_at: null };
+    }
+    const stat = data.insights_stats[insight];
+    if (isSuccess) stat.success_count++;
+    else stat.fail_count++;
+    stat.last_applied_at = now;
+  }
+
+  try { fs.writeFileSync(evoPath, JSON.stringify(data, null, 2), 'utf8'); } catch {}
 }
 
 // ─────────────────────────────────────────────
@@ -687,14 +730,24 @@ function smartStitch(skillDir) {
   sections.push('\n\n## User-Learned Best Practices & Constraints');
   sections.push('\n> **Auto-Generated Section**: Maintained by skill-evolution-manager. Do not edit manually.');
 
+  // Helper: get quality indicator for an insight based on stats
+  const getQualityTag = (insight) => {
+    const stat = data.insights_stats?.[insight];
+    if (!stat || stat.success_count + stat.fail_count < 3) return ''; // insufficient data
+    const total = stat.success_count + stat.fail_count;
+    const failRate = stat.fail_count / total;
+    if (failRate > 0.6) return ' ⚠️'; // >60% fail rate
+    return '';
+  };
+
   if (data.preferences?.length) {
     sections.push('\n### User Preferences');
-    for (const item of data.preferences) sections.push(`- ${item}`);
+    for (const item of data.preferences) sections.push(`- ${item}${getQualityTag(item)}`);
   }
 
   if (data.fixes?.length) {
     sections.push('\n### Known Fixes & Workarounds');
-    for (const item of data.fixes) sections.push(`- ${item}`);
+    for (const item of data.fixes) sections.push(`- ${item}${getQualityTag(item)}`);
   }
 
   if (data.custom_prompts) {
@@ -776,6 +829,7 @@ module.exports = {
   resolveQueueItem,
   mergeEvolution,
   smartStitch,
+  trackInsightOutcome,
   listInstalledSkills,
 };
 

package/scripts/utils.js

@@ -1,9 +1,64 @@
 'use strict';
 
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
 /**
  * utils.js — Pure utility functions extracted for testability.
  */
 
+// ---------------------------------------------------------
+// BRAIN FILE SAFE WRITE
+// Atomic write with exclusive file lock.
+// Prevents race condition between distill.js and daemon.js /quiet command.
+// ---------------------------------------------------------
+const BRAIN_LOCK_FILE = path.join(os.homedir(), '.metame', 'brain.lock');
+const BRAIN_FILE_DEFAULT = path.join(os.homedir(), '.claude_profile.yaml');
+
+/**
+ * Write content to the brain profile file atomically and exclusively.
+ * Uses a .lock file to prevent concurrent writes, and write-then-rename
+ * for atomicity (process crash leaves .tmp, not a partial BRAIN_FILE).
+ *
+ * @param {string} content - YAML string to write
+ * @param {string} [brainFile] - Target path (defaults to ~/.claude_profile.yaml)
+ * @returns {Promise<void>}
+ */
+async function writeBrainFileSafe(content, brainFile = BRAIN_FILE_DEFAULT) {
+  const maxRetries = 10;
+  const retryDelay = 150; // ms between retries
+  const staleTimeout = 30000; // 30s: lock older than this is stale
+
+  let acquired = false;
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      const fd = fs.openSync(BRAIN_LOCK_FILE, 'wx');
+      fs.writeSync(fd, process.pid.toString());
+      fs.closeSync(fd);
+      acquired = true;
+      break;
+    } catch (e) {
+      if (e.code !== 'EEXIST') throw e;
+      // Check for stale lock
+      try {
+        const age = Date.now() - fs.statSync(BRAIN_LOCK_FILE).mtimeMs;
+        if (age > staleTimeout) { fs.unlinkSync(BRAIN_LOCK_FILE); continue; }
+      } catch { /* lock removed by another process */ }
+      await new Promise(r => setTimeout(r, retryDelay));
+    }
+  }
+
+  const tmp = brainFile + '.tmp.' + process.pid;
+  try {
+    fs.writeFileSync(tmp, content, 'utf8');
+    fs.renameSync(tmp, brainFile); // atomic on POSIX
+  } finally {
+    try { fs.unlinkSync(tmp); } catch { } // clean up tmp if rename failed
+    if (acquired) try { fs.unlinkSync(BRAIN_LOCK_FILE); } catch { }
+  }
+}
+
 // ---------------------------------------------------------
 // INTERVAL PARSING
 // ---------------------------------------------------------
@@ -67,4 +122,6 @@ module.exports = {
   parseInterval,
   formatRelativeTime,
   createPathMap,
+  writeBrainFileSafe,
+  BRAIN_LOCK_FILE,
 };