metame-cli 1.1.3 → 1.2.1

package/scripts/pending-traits.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+/**
+ * MetaMe Pending Traits Manager
+ *
+ * Manages the accumulation and promotion of observed preferences.
+ * T3 fields need confidence threshold before writing to profile:
+ *   - high confidence (strong directive / correction) → direct write
+ *   - normal confidence → accumulate in pending, promote at count >= 3
+ *
+ * File: ~/.metame/pending_traits.yaml
+ * This file is system-internal, NOT injected into prompts.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const PENDING_FILE = path.join(os.homedir(), '.metame', 'pending_traits.yaml');
+const PROMOTION_THRESHOLD = 3;
+const EXPIRY_DAYS = 30;
+
+/**
+ * Load pending traits from disk.
+ * Returns plain object { 'dotted.key': { value, count, first_seen, last_seen, confidence, source_quote } }
+ */
+function loadPending() {
+  try {
+    if (!fs.existsSync(PENDING_FILE)) return {};
+    const yaml = require('js-yaml');
+    return yaml.load(fs.readFileSync(PENDING_FILE, 'utf8')) || {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Save pending traits to disk.
+ */
+function savePending(pending) {
+  const yaml = require('js-yaml');
+  const dir = path.dirname(PENDING_FILE);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(PENDING_FILE, yaml.dump(pending, { lineWidth: -1 }), 'utf8');
+}
+
+/**
+ * Upsert a trait observation into pending.
+ * If the value matches existing, increment count.
+ * If the value differs, start a new counter (contradiction).
+ */
+function upsertPending(pending, key, value, confidence, sourceQuote) {
+  const today = new Date().toISOString().slice(0, 10);
+  const existing = pending[key];
+
+  if (existing && existing.value === value) {
+    // Same value observed again — increment
+    existing.count += 1;
+    existing.last_seen = today;
+    if (confidence === 'high') existing.confidence = 'high';
+    if (sourceQuote) existing.source_quote = sourceQuote;
+  } else if (existing && existing.value !== value) {
+    // Contradiction — track it but don't delete old
+    if (!existing.contradictions) existing.contradictions = 0;
+    existing.contradictions += 1;
+    // If contradictions outnumber original observations, replace
+    if (existing.contradictions >= existing.count) {
+      pending[key] = {
+        value: value,
+        count: 1,
+        first_seen: today,
+        last_seen: today,
+        confidence: confidence || 'normal',
+        source_quote: sourceQuote || null
+      };
+    }
+  } else {
+    // New trait
+    pending[key] = {
+      value: value,
+      count: 1,
+      first_seen: today,
+      last_seen: today,
+      confidence: confidence || 'normal',
+      source_quote: sourceQuote || null
+    };
+  }
+}
+
+/**
+ * Get traits ready for promotion (count >= threshold OR confidence === 'high').
+ * Returns array of { key, value, source_quote }
+ */
+function getPromotable(pending) {
+  const ready = [];
+  for (const [key, meta] of Object.entries(pending)) {
+    if (meta.count >= PROMOTION_THRESHOLD || meta.confidence === 'high') {
+      ready.push({ key, value: meta.value, source_quote: meta.source_quote });
+    }
+  }
+  return ready;
+}
+
+/**
+ * Remove promoted traits from pending.
+ */
+function removePromoted(pending, keys) {
+  for (const key of keys) {
+    delete pending[key];
+  }
+}
+
+/**
+ * Expire stale pending traits (not observed for > EXPIRY_DAYS).
+ * Returns number of expired entries.
+ */
+function expireStale(pending) {
+  const now = Date.now();
+  const cutoff = EXPIRY_DAYS * 24 * 60 * 60 * 1000;
+  let expired = 0;
+
+  for (const [key, meta] of Object.entries(pending)) {
+    const lastSeen = new Date(meta.last_seen).getTime();
+    if (now - lastSeen > cutoff) {
+      delete pending[key];
+      expired++;
+    }
+  }
+  return expired;
+}
+
+module.exports = {
+  PENDING_FILE,
+  loadPending,
+  savePending,
+  upsertPending,
+  getPromotable,
+  removePromoted,
+  expireStale,
+  PROMOTION_THRESHOLD,
+  EXPIRY_DAYS,
+};

package/scripts/schema.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+
+/**
+ * MetaMe Profile Schema — Field Whitelist
+ *
+ * Defines every allowed field in the profile, its tier, data type,
+ * and constraints. The distiller can ONLY write keys listed here.
+ * This is the #1 anti-bloat measure.
+ *
+ * Tiers:
+ *   T1 — Identity (LOCKED, never auto-modify)
+ *   T2 — Core Values (LOCKED, deep personality)
+ *   T3 — Preferences (auto-writable, needs confidence)
+ *   T4 — Context (free overwrite, current state)
+ *   T5 — Evolution (system-managed, strict limits)
+ */
+
+const SCHEMA = {
+  // === T1: Identity ===
+  'identity.nickname':        { tier: 'T1', type: 'string', locked: true },
+  'identity.role':            { tier: 'T1', type: 'string', locked: false },
+  'identity.locale':          { tier: 'T1', type: 'string', locked: true },
+
+  // === T2: Core Values / Traits ===
+  'core_values.*':            { tier: 'T2', type: 'string', locked: true },
+  'core_traits.crisis_reflex':   { tier: 'T2', type: 'enum', locked: true, values: ['Action', 'Analysis', 'Delegation', 'Freeze'] },
+  'core_traits.flow_trigger':    { tier: 'T2', type: 'enum', locked: true, values: ['Ideation', 'Execution', 'Teaching', 'Debugging'] },
+  'core_traits.shadow_self':     { tier: 'T2', type: 'string', locked: true, maxChars: 80 },
+  'core_traits.learning_style':  { tier: 'T2', type: 'enum', locked: true, values: ['Hands-on', 'Conceptual', 'Social', 'Reflective'] },
+  'core_traits.north_star.aspiration': { tier: 'T2', type: 'string', locked: true, maxChars: 80 },
+  'core_traits.north_star.realistic':  { tier: 'T2', type: 'string', locked: true, maxChars: 80 },
+
+  // === T3: Preferences ===
+  'preferences.code_style':       { tier: 'T3', type: 'enum', values: ['concise', 'verbose', 'documented'] },
+  'preferences.communication':    { tier: 'T3', type: 'enum', values: ['direct', 'gentle', 'socratic'] },
+  'preferences.language_mix':     { tier: 'T3', type: 'enum', values: ['zh-only', 'en-only', 'zh-main-en-term', 'code-switch'] },
+  'preferences.tech_terms_language': { tier: 'T3', type: 'enum', values: ['zh', 'en'] },
+  'preferences.code_comments_language': { tier: 'T3', type: 'enum', values: ['zh', 'en', null] },
+  'preferences.explanation_depth': { tier: 'T3', type: 'enum', values: ['result_only', 'brief_rationale', 'deep_dive'] },
+  'preferences.interaction_tempo': { tier: 'T3', type: 'enum', values: ['batch', 'incremental'] },
+  'preferences.tools':            { tier: 'T3', type: 'array', maxItems: 10 },
+  'preferences.anti_patterns':    { tier: 'T3', type: 'array', maxItems: 5 },
+
+  // === T3b: Cognition ===
+  'cognition.decision_style':               { tier: 'T3', type: 'enum', values: ['intuitive', 'analytical', 'adaptive'] },
+  'cognition.info_processing.entry_point':  { tier: 'T3', type: 'enum', values: ['big_picture', 'details', 'examples'] },
+  'cognition.info_processing.preferred_format': { tier: 'T3', type: 'enum', values: ['structured', 'narrative', 'visual_metaphor'] },
+  'cognition.abstraction.default_level':    { tier: 'T3', type: 'enum', values: ['strategic', 'architectural', 'implementation', 'operational'] },
+  'cognition.abstraction.range':            { tier: 'T3', type: 'enum', values: ['narrow', 'wide'] },
+  'cognition.cognitive_load.chunk_size':    { tier: 'T3', type: 'enum', values: ['small', 'medium', 'large'] },
+  'cognition.cognitive_load.preferred_response_length': { tier: 'T3', type: 'enum', values: ['concise', 'moderate', 'comprehensive'] },
+  'cognition.motivation.primary_driver':    { tier: 'T3', type: 'enum', values: ['autonomy', 'competence', 'meaning', 'social_proof'] },
+  'cognition.motivation.energy_source':     { tier: 'T3', type: 'enum', values: ['creation', 'optimization', 'problem_solving', 'teaching'] },
+  'cognition.metacognition.self_awareness': { tier: 'T3', type: 'enum', values: ['high', 'medium', 'low'] },
+  'cognition.metacognition.receptive_to_challenge': { tier: 'T3', type: 'enum', values: ['yes', 'sometimes', 'no'] },
+
+  // === T4: Context ===
+  'context.focus':             { tier: 'T4', type: 'string', maxChars: 80 },
+  'context.focus_since':       { tier: 'T4', type: 'string' },
+  'context.active_projects':   { tier: 'T4', type: 'array', maxItems: 5 },
+  'context.blockers':          { tier: 'T4', type: 'array', maxItems: 3 },
+  'context.energy':            { tier: 'T4', type: 'enum', values: ['high', 'medium', 'low', null] },
+  'status.focus':              { tier: 'T4', type: 'string', maxChars: 80 },
+  'status.language':           { tier: 'T4', type: 'string' },
+
+  // === T5: Evolution (system-managed) ===
+  'evolution.last_distill':    { tier: 'T5', type: 'string' },
+  'evolution.distill_count':   { tier: 'T5', type: 'number' },
+  'evolution.recent_changes':  { tier: 'T5', type: 'array', maxItems: 5 },
+  'evolution.auto_distill':    { tier: 'T5', type: 'array', maxItems: 10 },
+};
+
+/**
+ * Check if a dotted key matches the schema.
+ * Supports wildcard entries like 'core_values.*'
+ */
+function hasKey(key) {
+  if (SCHEMA[key]) return true;
+  // Check wildcard patterns
+  const parts = key.split('.');
+  for (let i = parts.length - 1; i >= 1; i--) {
+    const wildcard = parts.slice(0, i).join('.') + '.*';
+    if (SCHEMA[wildcard]) return true;
+  }
+  return false;
+}
+
+/**
+ * Get schema definition for a key (or its wildcard parent).
+ */
+function getDefinition(key) {
+  if (SCHEMA[key]) return SCHEMA[key];
+  const parts = key.split('.');
+  for (let i = parts.length - 1; i >= 1; i--) {
+    const wildcard = parts.slice(0, i).join('.') + '.*';
+    if (SCHEMA[wildcard]) return SCHEMA[wildcard];
+  }
+  return null;
+}
+
+/**
+ * Get the tier for a key.
+ */
+function getTier(key) {
+  const def = getDefinition(key);
+  return def ? def.tier : null;
+}
+
+/**
+ * Check if a key is locked.
+ */
+function isLocked(key) {
+  const def = getDefinition(key);
+  return def ? !!def.locked : false;
+}
+
+/**
+ * Validate a value against its schema definition.
+ * Returns { valid: boolean, reason?: string }
+ */
+function validate(key, value) {
+  const def = getDefinition(key);
+  if (!def) return { valid: false, reason: 'Key not in schema' };
+
+  if (def.type === 'enum') {
+    if (!def.values.includes(value)) {
+      return { valid: false, reason: `Value must be one of: ${def.values.join(', ')}` };
+    }
+  }
+
+  if (def.type === 'string' && typeof value === 'string') {
+    if (def.maxChars && value.length > def.maxChars) {
+      return { valid: false, reason: `String exceeds ${def.maxChars} chars` };
+    }
+  }
+
+  if (def.type === 'array' && Array.isArray(value)) {
+    if (def.maxItems && value.length > def.maxItems) {
+      return { valid: false, reason: `Array exceeds ${def.maxItems} items` };
+    }
+  }
+
+  return { valid: true };
+}
+
+/**
+ * Get all allowed keys as a formatted list (for injection into prompts).
+ */
+function getAllowedKeysForPrompt() {
+  const lines = [];
+  let currentTier = '';
+  for (const [key, def] of Object.entries(SCHEMA)) {
+    if (def.tier !== currentTier) {
+      currentTier = def.tier;
+      lines.push(`\n# ${currentTier}${def.locked ? ' (LOCKED — do NOT write)' : ''}:`);
+    }
+    let desc = `  ${key}: ${def.type}`;
+    if (def.values) desc += ` [${def.values.join('|')}]`;
+    if (def.maxChars) desc += ` (max ${def.maxChars} chars)`;
+    if (def.maxItems) desc += ` (max ${def.maxItems} items)`;
+    if (def.locked) desc += ' [LOCKED]';
+    lines.push(desc);
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Estimate token count for a YAML string (conservative for mixed zh/en).
+ */
+function estimateTokens(yamlString) {
+  return Math.ceil(yamlString.length / 3);
+}
+
+const TOKEN_BUDGET = 800;
+
+module.exports = {
+  SCHEMA,
+  hasKey,
+  getDefinition,
+  getTier,
+  isLocked,
+  validate,
+  getAllowedKeysForPrompt,
+  estimateTokens,
+  TOKEN_BUDGET,
+};

package/scripts/signal-capture.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+/**
+ * MetaMe Signal Capture Hook
+ *
+ * Runs as a Claude Code UserPromptSubmit hook.
+ * Receives user prompt via stdin JSON, filters for potential
+ * persistent preferences/identity signals, appends to buffer.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const BUFFER_FILE = path.join(os.homedir(), '.metame', 'raw_signals.jsonl');
+const MAX_BUFFER_LINES = 50; // Safety cap to avoid unbounded growth
+
+// === CONFIDENCE PATTERNS ===
+
+// Strong directive signals → high confidence (direct write to T3)
+// Allow up to 6 chars between key words (e.g. "以后代码一律" = "以后" + "代码" + "一律")
+const STRONG_SIGNAL_ZH = /以后.{0,6}(都|一律|每次|全部|统一)|永远.{0,4}(不要|别|不能|要)|千万.{0,4}(别|不要)|记住|一定.{0,4}(要|得)|一律|统一用/;
+const STRONG_SIGNAL_EN = /(from now on|always|never|don't ever|remember to|every time)/i;
+
+// Implicit preference signals → normal confidence (needs accumulation)
+const IMPLICIT_ZH = /我(喜欢|偏好|习惯|讨厌|不喜欢|一般都|通常|总是|倾向于)/;
+const IMPLICIT_EN = /I (prefer|like|hate|usually|tend to|always)/i;
+
+// Correction signals → high confidence (user is teaching us)
+const CORRECTION_ZH = /不是.*我(要|想|说)的|我说的不是|你理解错了|不对.*应该/;
+const CORRECTION_EN = /(no,? I meant|that's not what I|you misunderstood|wrong.+should be)/i;
+
+// Read JSON from stdin
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input);
+    const prompt = (data.prompt || '').trim();
+
+    // === LAYER 1: Hard filters (definitely not preferences) ===
+
+    // Skip empty or very short messages
+    // Chinese chars carry more info per char, so use weighted length
+    const weightedLen = [...prompt].reduce((sum, ch) => sum + (ch.charCodeAt(0) > 0x2e80 ? 3 : 1), 0);
+    if (weightedLen < 15) {
+      process.exit(0);
+    }
+
+    // Skip messages that are purely code or file paths
+    if (/^(```|\/[\w/]+\.\w+$)/.test(prompt)) {
+      process.exit(0);
+    }
+
+    // Skip common non-preference commands
+    if (/^(\/\w+|!metame|git |npm |pnpm |yarn |brew |sudo |cd |ls |cat |mkdir )/.test(prompt)) {
+      process.exit(0);
+    }
+
+    // Skip pure task instructions (fix/add/delete/refactor/debug/deploy/test/run/build)
+    if (/^(帮我|请你|麻烦)?\s*(fix|add|delete|remove|refactor|debug|deploy|test|run|build|create|update|implement|write|generate|make)/i.test(prompt)) {
+      process.exit(0);
+    }
+    if (/^(帮我|请你|麻烦)?\s*(修|加|删|重构|调试|部署|测试|运行|构建|创建|更新|实现|写|生成|做)/.test(prompt)) {
+      process.exit(0);
+    }
+
+    // Skip pasted error logs / stack traces
+    if (/^(Error|TypeError|SyntaxError|ReferenceError|at\s+\w+|Traceback|FATAL|WARN|ERR!)/i.test(prompt)) {
+      process.exit(0);
+    }
+    if (prompt.split('\n').length > 10) {
+      // Multi-line pastes are usually code or logs, not preferences
+      process.exit(0);
+    }
+
+    // Skip pure questions with no preference signal
+    if (/^(what|how|why|where|when|which|can you|could you|is there|are there|does|do you)\s/i.test(prompt) &&
+        !/prefer|like|hate|always|never|style|习惯|偏好|喜欢|讨厌/.test(prompt)) {
+      process.exit(0);
+    }
+    if (/^(什么|怎么|为什么|哪|能不能|可以|是不是)\s/.test(prompt) &&
+        !/偏好|喜欢|讨厌|习惯|以后|一律|总是|永远|记住/.test(prompt)) {
+      process.exit(0);
+    }
+
+    // === LAYER 2: Confidence tagging ===
+    const isStrong = STRONG_SIGNAL_ZH.test(prompt) || STRONG_SIGNAL_EN.test(prompt);
+    const isCorrection = CORRECTION_ZH.test(prompt) || CORRECTION_EN.test(prompt);
+    const confidence = (isStrong || isCorrection) ? 'high' : 'normal';
+
+    // Append to buffer
+    const entry = {
+      ts: new Date().toISOString(),
+      prompt: prompt,
+      confidence: confidence,
+      session: data.session_id || null,
+      cwd: data.cwd || null
+    };
+
+    // Append to buffer, drop oldest if over cap
+    let existingLines = [];
+    try {
+      existingLines = fs.readFileSync(BUFFER_FILE, 'utf8')
+        .split('\n').filter(l => l.trim());
+    } catch {
+      // File doesn't exist yet, that's fine
+    }
+
+    existingLines.push(JSON.stringify(entry));
+
+    // Keep only the most recent entries (drop oldest)
+    if (existingLines.length > MAX_BUFFER_LINES) {
+      existingLines = existingLines.slice(-MAX_BUFFER_LINES);
+    }
+
+    fs.writeFileSync(BUFFER_FILE, existingLines.join('\n') + '\n');
+
+  } catch {
+    // Silently ignore parse errors — never block the user's workflow
+  }
+
+  process.exit(0);
+});

package/README/344/270/255/346/226/207/347/211/210.md

@@ -1,175 +0,0 @@
-# 🔮 MetaMe
-
-<p align="center">
-  <img src="./logo.png" alt="MetaMe Logo" width="200"/>
-</p>
-
-> **Claude Code 的“元认知”层 (The Meta-Cognitive Layer)**
->
-> *将你的 AI 助手变成一面心理镜像：它了解你，随你进化，并时刻守护你的核心原则。*
-
-## 📖 简介 (Introduction)
-
-**Claude Code** 是一个强大的工具，但它患有“项目失忆症”。每当你切换文件夹时，它就会忘记你是谁、你的沟通风格以及你的具体限制。
-
-**MetaMe** 通过为 Claude 包裹一层 **“元认知层”** 来解决这个问题。它创建了一个跟随你穿梭于所有项目的  **“全局大脑”** 。它了解你的心理画像，监控你的压力状态，并尊重你的核心原则——无需你每次重复强调。
-
-它不仅仅是一个启动器；它是你的  **元分身 (Meta Avatar)** 。
-
-## ✨ 核心特性 (Key Features)
-
-* **🧠 全局大脑 (`~/.claude_profile.yaml`)：** 关于你身份的“唯一真理来源”。存储你的昵称、压力状态和认知特征，跨项目共享。
-* **🧬 进化机制 (Evolution Mechanism)：** 你掌握控制权。使用 `!metame evolve` 手动教导 Claude 你的新偏好或限制，确保它在每次交互中变得更聪明。
-* **🤝 动态握手协议 (Dynamic Handshake)：** 即“金丝雀测试”。MetaMe 会强制 AI 在回复的第一句话中通过你的 **代号 (Codename)** 来称呼你。如果它没叫你的名字，你就知道元认知连接已断开。
-* **🛡️ 自动锁定机制 (Auto-Lock)：** 在配置文件中为任何值添加 `# [LOCKED]`，MetaMe 就会将其视为不可动摇的“宪法”，防止 AI 随意修改。
-* **🔌 智能注入 (Smart Injection)：** 自动将你的个人档案注入到你进入的任何项目的 `CLAUDE.md` 中，实现无缝的上下文切换。
-
-## 🛠 前置要求 (Prerequisites)
-
-MetaMe 是 **Claude Code** 的外壳。你必须先安装 Node.js 和官方的 Claude Code 工具。
-
-1. **Node.js** : 版本 14 或更高。
-2. **Claude Code** :
-   **Bash**
-
-```
-   npm install -g @anthropic-ai/claude-code
-```
-
-1. **认证** : 确保你已经运行过 `claude login` 并登录成功。
-
-## 📦 安装 (Installation)
-
-通过 NPM 全局安装 MetaMe：
-
-**Bash**
-
-```
-npm install -g metame-cli
-```
-
-*(注意：如果你在 Mac/Linux 上遇到权限错误，请使用 `sudo npm install -g metame-cli`)*
-
-## 🚀 使用指南 (Usage)
-
-忘掉 `claude` 命令吧。从现在起，只需输入：
-
-**Bash**
-
-```
-metame
-```
-
-或者，如果你喜欢混合大小写（效果一样）：
-
-**Bash**
-
-```
-MetaMe
-```
-
-### 初次运行：创世纪 (The First Run)
-
-当你第一次运行 MetaMe 时，它会检测到你的档案为空。它会暂停 AI 并进入 **校准模式 (Calibration Mode)** ：
-
-1. 它会询问你的 **代号 (Codename/Nickname)**。
-2. 它会开启一场 **深度认知访谈**，探索你的天赋领域、思维模式和潜在焦虑。
-3. **请务必诚实**：它是一面镜子。你越坦诚（即便是关于你的恐惧），它就越能成为你的完美分身。
-4. 完成后，它会保存你的“源代码”并启动 Claude。
-
-### 日常工作流
-
-1. `cd` 进入任何项目文件夹。
-2. 运行 `metame`。
-3. Claude 启动并立即说：*“Ready, [你的名字]...”*
-4. 开始写代码。MetaMe 会在后台自动管理上下文。
-
-### 热重载 (Hot Reload)
-
-如果你更新了个人档案，或者需要修复断开的上下文连接，而**不想重启会话**：
-
-*   **在 Claude 内部**：运行 `!metame refresh`
-*   **在外部终端**：运行 `metame refresh`
-
-这会立即将你最新的档案重新注入 `CLAUDE.md`。
-
-## ⚙️ 配置与“全局大脑”
-
-你的个人档案存储在你用户主目录下的一个隐藏 YAML 文件中。
-
-**位置：** `~/.claude_profile.yaml`
-
-你可以手动编辑此文件来更新你的状态或锁定你的价值观。
-
-**档案示例：**
-
-**YAML**
-
-```
-identity:
-  role: Senior Architect
-  nickname: Neo
-status:
-  focus: Refactoring Legacy Code
-  pressure: High
-cognition:
-  crisis_reflex: Strategic_Analysis
-  blind_spot: Perfectionism # [LOCKED]
-values:
-  core: "User Experience First" # [LOCKED]
-```
-
-* **`# [LOCKED]`** ：添加此注释可确保即使 AI 随着时间推移进化你的档案，这些特定的行也 **永远不会** 被覆盖。
-
-## 🗑️ 卸载 (Uninstallation)
-
-如果你希望从系统中彻底移除 MetaMe，请按照以下步骤操作：
-
-### 1. 移除软件包
-
-卸载 CLI 工具：
-
-**Bash**
-
-```
-npm uninstall -g metame-cli
-```
-
-### 2. 移除全局大脑（可选）
-
-如果你想删除存储的个人档案数据：
-
-**Bash**
-
-```
-rm ~/.claude_profile.yaml
-```
-
-### 3. 清理项目文件（可选）
-
-MetaMe 会在项目的 `CLAUDE.md` 文件头部添加一段协议。如果你想恢复原状，可以用文本编辑器删除以 `## 🧠 SYSTEM KERNEL` 开头的块。
-
-## ⚡ 性能与成本 (Performance & Cost)
-
-你可能会担心：*“这会吃掉我的上下文窗口吗？”*
-
-**简短回答：不会。它甚至通过减少废话为你省钱。**
-
-*   **上下文占用**：整个 MetaMe 内核 + 你的完整档案仅占用 **约 800 - 1000 tokens**。
-*   **占比**：在 Claude 的 200k 上下文窗口中，这仅占 **0.5%**。
-*   **投资回报**：通过预加载你的完整背景，它避免了每个新会话开头的“磨合期”和重复指令修正，而那些通常会浪费数千 tokens。
-
-## ❓ 常见问题 (FAQ)
-
-**Q: 这会覆盖我原本的 `CLAUDE.md` 吗？**
-A: 不会。它只是将元认知协议 *插入* 到你现有 `CLAUDE.md` 的最顶部。你原本的项目笔记会保持原样。
-
-**Q: 如果 Claude 突然不再叫我的昵称了怎么办？**
-A: 这就是“金丝雀测试”失败了。这意味着上下文窗口被压缩了，或者文件链接断开了。在 Claude 中运行 `/compact` 或重启 `metame` 即可修复。
-
-**Q: 我的数据会被发送给第三方吗？**
-A: 不会。你的档案只保存在本地的 `~/.claude_profile.yaml` 中。MetaMe 只是将文本传递给官方的 Claude Code 工具。
-
-## 📄 许可证 (License)
-
-MIT License. 欢迎 Fork、修改并进化你自己的元认知系统。