metame-cli 1.4.32 → 1.4.34

package/README.md

@@ -1,7 +1,7 @@
 # MetaMe
 
 <p align="center">
-  <img src="./logo.png" alt="MetaMe Logo" width="200"/>
+  <img src="./logo_high_contrast.png" alt="MetaMe Logo" width="200"/>
 </p>
 
 <p align="center">
@@ -24,7 +24,7 @@ No cloud. Your machine, your data.
 curl -fsSL https://raw.githubusercontent.com/Yaron9/MetaMe/main/install.sh | bash
 ```
 
-**Already have Node.js ≥ 18:**
+**Already have Node.js ≥ 22.5:**
 ```bash
 npm install -g metame-cli
 metame
@@ -38,13 +38,15 @@ metame
 
 ---
 
-> ### 🚀 v1.4.19 — Multi-User ACL + Session Context Preview
+> ### 🚀 v1.4.33 — 6-Dimension Soul Schema + Nightly Reflection + Auto-Provisioning
 >
-> - **Multi-user permission system**: role-based ACL (admin / member / stranger) — share your bots with teammates without giving them full access. Manage users with `/user` commands.
-> - **Session context preview**: `/resume` and `/sessions` now show the last message snippet so you know exactly what to pick up.
-> - **Team Task protocol**: multi-agent task board for cross-agent collaboration. Agents can dispatch and track tasks across workspaces.
-> - **Layered Memory Architecture**: three-layer memory (long-term facts, session summaries, session index) — all automatic.
-> - **Unix Socket IPC**: dispatch latency <100ms.
+> - **6-dimension soul schema**: cognitive profile upgraded from key-value pairs to a structured 67-field model covering Values, Drive, Cognition Style, Stress & Shadow, Relational, and Identity Narrative — with tier-based lock protection.
+> - **Nightly reflection**: every night, hot-zone facts are distilled into searchable decision logs and lessons learned.
+> - **Memory index**: auto-generated global index of all memory documents for instant retrieval.
+> - **Auto-provisioning**: first run automatically deploys default CLAUDE.md, docs, and `dispatch_to` — zero manual setup.
+> - **Token budget tracking**: daily token usage monitoring with per-category breakdown and 80% warning threshold.
+> - **Multi-user ACL**: role-based permissions (admin / member / stranger) with binding protection.
+> - **Windows native support**: cross-platform path handling, Named Pipes IPC, GBK-safe encoding.
 >
 > Zero configuration. It just works.
 
@@ -56,7 +58,9 @@ metame
 
 Claude Code forgets you every time you switch folders. MetaMe doesn't.
 
-A cognitive profile (`~/.claude_profile.yaml`) follows you everywhere — not just facts like "user prefers TypeScript", but *how you think*: your decision style, cognitive load preferences, communication patterns. It learns silently from your conversations via background distillation, no effort required.
+A cognitive profile (`~/.claude_profile.yaml`) follows you everywhere — not just facts like "user prefers TypeScript", but *how you think*. The profile is built on a **6-dimension soul schema**: Values, Drive, Cognition Style, Stress & Shadow, Relational, and Identity Narrative — 67 fields organized into 4 tiers (T1 locked identity → T5 system-managed evolution). First-time users go through a **Genesis Interview**: a structured deep conversation that builds your cognitive fingerprint from scratch.
+
+Once established, the profile updates silently from your conversations via background distillation — no effort required.
 
 ```
 $ metame
@@ -80,7 +84,7 @@ Start on your laptop, continue on the train. `/stop` to interrupt, `/undo` to ro
 
 ### 3. Layered Memory That Works While You Sleep
 
-MetaMe's memory system runs automatically in the background — no prompts, no manual saves.
+MetaMe's memory system runs automatically in the background — no prompts, no manual saves. Five layers, fully autonomous.
 
 **Layer 1 — Long-term Facts**
 When you go idle, MetaMe runs memory consolidation: extracts key decisions, patterns, and knowledge from your sessions into a persistent facts store. These are semantically recalled on every session start.
@@ -91,12 +95,20 @@ Resuming a conversation after 2+ hours? MetaMe injects a brief summary of what y
 **Layer 3 — Session Index**
 Every session gets tagged with topics and intent. This powers future session routing: when you reference "that thing we worked on last week", MetaMe knows where to look.
 
+**Layer 4 — Nightly Reflection**
+Every night at 01:00, MetaMe reviews your most-accessed facts from the past week and distills them into high-level decision logs and operational lessons — searchable documents that grow your personal knowledge base over time.
+
+**Layer 5 — Memory Index**
+At 01:30, an auto-generated global index (`INDEX.md`) maps every memory document across all categories. This serves as a fast lookup table so MetaMe always knows where to find relevant context.
+
 ```
 [Background, while you sleep]
 idle 30min → memory consolidation triggered
   → session_tags.json updated (topics indexed)
   → facts extracted → ~/.metame/memory.db
   → session summary cached → daemon_state.json
+01:00 → nightly reflection: hot facts → decisions + lessons
+01:30 → memory index regenerated
 
 [Next morning, when you resume]
 "continue from yesterday" →
@@ -117,12 +129,14 @@ Built into the daemon. Runs every 60 seconds regardless of what's in your config
 - Detects when you go idle → generates session continuity summaries
 
 **Layer 1 — System Evolution (built-in defaults)**
-Three tasks shipped out of the box. They are precondition-gated and run only when useful:
+Five tasks shipped out of the box. They are precondition-gated and run only when useful:
 
 ```yaml
 - cognitive-distill   # 4h · has signals? → distill preferences into profile
 - memory-extract      # 4h · scan sessions → extract long-term facts + topic tags
 - skill-evolve        # 6h · has signals? → evolve skills from task outcomes
+- nightly-reflect     # 01:00 daily · hot facts → decision logs + lessons learned
+- memory-index        # 01:30 daily · regenerate global memory index
 ```
 
 `precondition` guards mean zero tokens burned when there's nothing to process.
@@ -203,19 +217,21 @@ Task fails → skill-scout finds a skill → installs → retries → succeeds
 curl -fsSL https://raw.githubusercontent.com/Yaron9/MetaMe/main/install.sh | bash
 ```
 
-**Already have Node.js ≥ 18:**
+**Already have Node.js ≥ 22.5:**
 ```bash
 npm install -g metame-cli
 metame
 ```
 
+> **First run auto-provisioning:** MetaMe automatically deploys a default `CLAUDE.md`, documentation files, and the `dispatch_to` tool to `~/.metame/`. No manual setup needed.
+
 **Setup guide (3 minutes):**
 
 | Step | What to do | What happens |
 |------|-----------|-------------|
 | 1. Log in to Claude | Run `claude` and complete the login (Anthropic account or API key) | Claude Code is ready to use |
 | 2. Launch MetaMe | Run `metame` | Opens a Claude session with MetaMe loaded |
-| 3. Cognitive interview | Just chat — MetaMe will automatically start a deep interview on first run | Builds `~/.claude_profile.yaml` (your digital twin's brain) |
+| 3. Genesis Interview | Just chat — MetaMe will automatically start a deep soul interview on first run | Builds `~/.claude_profile.yaml` (6-dimension cognitive profile) |
 | 4. Connect phone | Say "help me set up mobile access" or "connect my phone" | Interactive wizard for Telegram/Feishu bot setup → `~/.metame/daemon.yaml` |
 | 5. Start daemon | `metame start` | Background daemon launches, bot goes online |
 | 6. Register with system | macOS: `metame daemon install-launchd` · Windows: `metame daemon install-task-scheduler` · Linux: see below | Always-on, crash recovery |
@@ -281,11 +297,13 @@ systemctl --user start metame
 
 | Capability | What It Does |
 |-----------|-------------|
-| **Cognitive Profile** | Learns how you think across sessions. Schema-enforced, 800-token budget, auto-distilled via Haiku. Lock any value with `# [LOCKED]`. |
-| **Layered Memory** | Three-tier memory: long-term facts (semantic recall), session summaries (continuity bridge), session index (topic tags). All automatic. |
+| **Cognitive Profile** | 6-dimension soul schema (Values, Drive, Cognition Style, Stress & Shadow, Relational, Identity Narrative). 67 fields, tier-locked, 800-token budget. First-time Genesis Interview builds your profile from scratch. |
+| **Layered Memory** | Five-tier memory: long-term facts (semantic recall), session summaries (continuity bridge), session index (topic tags), nightly reflection (decision/lesson distillation), memory index (global lookup). All automatic. |
 | **Mobile Bridge** | Full Claude Code via Telegram/Feishu. Stateful sessions, file transfer both ways, real-time streaming status. |
 | **Skill Evolution** | Self-healing skill system. Auto-discovers missing skills, learns from browser recordings, evolves after every task. Skills get smarter over time. |
-| **Heartbeat System** | Three-layer programmable nervous system. Layer 0 kernel always-on (zero config). Layer 1 system evolution built-in (distill + memory + skills). Layer 2 your custom scheduled tasks with `require_idle`, `precondition`, `notify`, workflows. |
+| **Token Budget** | Daily token usage tracking with per-category breakdown. Configurable daily limit, automatic 80% warning threshold, usage history with rollover. |
+| **Auto-Provisioning** | First run deploys default CLAUDE.md, documentation, and `dispatch_to` to `~/.metame/`. Subsequent runs sync scripts without overwriting user config. |
+| **Heartbeat System** | Three-layer programmable nervous system. Layer 0 kernel always-on (zero config). Layer 1 system evolution built-in (5 tasks: distill + memory + skills + nightly reflection + memory index). Layer 2 your custom scheduled tasks with `require_idle`, `precondition`, `notify`, workflows. |
 | **Multi-Agent** | Multiple projects with dedicated chat groups. `/agent bind` for one-tap setup. True parallel execution. |
 | **Browser Automation** | Built-in Playwright MCP. Browser control out of the box for every user. |
 | **Cross-Platform** | Native support for macOS and Windows. Platform abstraction layer handles spawn, IPC, process management, and terminal encoding automatically. |
@@ -429,27 +447,34 @@ All agents share your cognitive profile (`~/.claude_profile.yaml`) — they all
                                           │   └──────────────┘           │
                                           │                              │
                                           │   ~/.claude_profile          │
-                                          │   (cognitive layer)          │
+                                          │   (6-dim soul schema)        │
                                           │                              │
                                           │   ~/.metame/memory.db        │
                                           │   session_tags.json          │
-                                          │   (memory layer)  ← NEW      │
+                                          │   (5-layer memory)           │
+                                          │                              │
+                                          │   dispatch_to (auto-deployed)│
                                           └──────────────────────────────┘
                                                        ↑
-                                          idle mode → summaries + background memory tasks
-                                                      (automatic, precondition-gated)
+                                          idle → summaries + memory tasks
+                                          01:00 → nightly reflection
+                                          01:30 → memory index rebuild
 ```
 
-- **Profile** (`~/.claude_profile.yaml`): Your cognitive fingerprint. Injected into every Claude session via `CLAUDE.md`.
-- **Daemon** (`scripts/daemon.js`): Background process handling Telegram/Feishu messages, heartbeat tasks, Unix socket dispatch, and idle/sleep transitions.
-- **Distillation** (`scripts/distill.js`): Heartbeat task (default 4h, signal-gated) that updates your profile.
-- **Memory Extract** (`scripts/memory-extract.js`): Heartbeat task (default 4h, idle-gated) that extracts long-term facts and session topic tags.
-- **Session Summarize** (`scripts/session-summarize.js`): Generates a 2-4 sentence summary for idle sessions. Injected as context when resuming after a 2h+ gap.
+- **Profile** (`~/.claude_profile.yaml`): 6-dimension soul schema. Injected into every Claude session via `CLAUDE.md`.
+- **Daemon**: Background process handling Telegram/Feishu messages, heartbeat tasks, Unix socket dispatch, and idle/sleep transitions.
+- **Distillation**: Heartbeat task (4h, signal-gated) that updates your cognitive profile.
+- **Memory Extract**: Heartbeat task (4h, idle-gated) that extracts long-term facts and session topic tags.
+- **Nightly Reflection**: Daily at 01:00. Distills hot-zone facts into decision logs and operational lessons.
+- **Memory Index**: Daily at 01:30. Regenerates the global memory index for fast retrieval.
+- **Session Summarize**: Generates a brief summary for idle sessions. Injected as context when resuming after a 2h+ gap.
 
 ## Security
 
 - All data stays on your machine. No cloud, no telemetry.
 - `allowed_chat_ids` whitelist — new groups get a smart prompt: if a pending agent activation exists, they're guided to send `/activate`; otherwise they receive setup instructions.
+- **Multi-user ACL**: role-based permissions (admin / member / stranger). Admins manage access via `/user` commands with hot-reload config.
+- **Binding protection**: each group can only be bound to one agent. Existing bindings cannot be overwritten without explicit `force:true`.
 - `operator_ids` for shared groups — non-operators get read-only mode.
 - `~/.metame/` directory is mode 700.
 - Bot tokens stored locally, never transmitted.
@@ -460,7 +485,7 @@ All agents share your cognitive profile (`~/.claude_profile.yaml`) — they all
 |--------|-------|
 | Daemon memory (idle) | ~100 MB RSS — standard Node.js process baseline |
 | Daemon CPU (idle, between heartbeats) | ~0% — event-loop sleeping |
-| Cognitive profile injection | ~600 tokens/session (0.3% of 200k context) |
+| Cognitive profile injection | ~800 tokens/session (0.4% of 200k context) |
 | Dispatch latency (Unix socket) | <100ms |
 | Memory consolidation (per session) | ~1,500–2,000 tokens input + ~50–300 tokens output (Haiku) |
 | Session summary (per session) | ~400–900 tokens input + ≤250 tokens output (Haiku) |

package/index.js

@@ -50,6 +50,41 @@ if (!fs.existsSync(METAME_DIR)) {
   fs.mkdirSync(METAME_DIR, { recursive: true });
 }
 
+// ---------------------------------------------------------
+// DEPLOY PHASE: sync scripts, docs, bin to ~/.metame/
+// ---------------------------------------------------------
+
+/**
+ * Sync files from srcDir to destDir. Only writes when content differs.
+ * @param {string} srcDir - source directory
+ * @param {string} destDir - destination directory
+ * @param {object} [opts]
+ * @param {string[]} [opts.fileList] - explicit file list (skip readdirSync)
+ * @param {number}  [opts.chmod] - chmod after write (e.g. 0o755)
+ * @returns {boolean} true if any file was updated
+ */
+function syncDirFiles(srcDir, destDir, { fileList, chmod } = {}) {
+  if (!fs.existsSync(srcDir)) return false;
+  if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
+  let updated = false;
+  const files = fileList || fs.readdirSync(srcDir).filter(f => fs.statSync(path.join(srcDir, f)).isFile());
+  for (const f of files) {
+    const src = path.join(srcDir, f);
+    const dest = path.join(destDir, f);
+    try {
+      if (!fs.existsSync(src)) continue;
+      const srcContent = fs.readFileSync(src, 'utf8');
+      const destContent = fs.existsSync(dest) ? fs.readFileSync(dest, 'utf8') : '';
+      if (srcContent !== destContent) {
+        fs.writeFileSync(dest, srcContent, 'utf8');
+        if (chmod) try { fs.chmodSync(dest, chmod); } catch { /* Windows */ }
+        updated = true;
+      }
+    } catch { /* non-fatal per file */ }
+  }
+  return updated;
+}
+
 // Auto-deploy bundled scripts to ~/.metame/
 // IMPORTANT: daemon.yaml is USER CONFIG — never overwrite it. Only daemon-default.yaml (template) is synced.
 const scriptsDir = path.join(__dirname, 'scripts');
@@ -75,23 +110,7 @@ try {
   }
 } catch { /* non-fatal */ }
 
-let scriptsUpdated = false;
-for (const script of BUNDLED_SCRIPTS) {
-  const src = path.join(scriptsDir, script);
-  const dest = path.join(METAME_DIR, script);
-  try {
-    if (fs.existsSync(src)) {
-      const srcContent = fs.readFileSync(src, 'utf8');
-      const destContent = fs.existsSync(dest) ? fs.readFileSync(dest, 'utf8') : '';
-      if (srcContent !== destContent) {
-        fs.writeFileSync(dest, srcContent, 'utf8');
-        scriptsUpdated = true;
-      }
-    }
-  } catch {
-    // Non-fatal
-  }
-}
+const scriptsUpdated = syncDirFiles(scriptsDir, METAME_DIR, { fileList: BUNDLED_SCRIPTS });
 
 // Daemon restart on script update:
 // Don't kill daemon here — daemon's own file watcher detects ~/.metame/daemon.js changes
@@ -101,6 +120,11 @@ if (scriptsUpdated) {
   console.log(`${icon("pkg")} Scripts synced to ~/.metame/ — daemon will auto-restart when idle.`);
 }
 
+// Docs: lazy-load references for CLAUDE.md pointer instructions
+syncDirFiles(path.join(__dirname, 'scripts', 'docs'), path.join(METAME_DIR, 'docs'));
+// Bin: CLI tools (dispatch_to etc.)
+syncDirFiles(path.join(__dirname, 'scripts', 'bin'), path.join(METAME_DIR, 'bin'), { chmod: 0o755 });
+
 // ---------------------------------------------------------
 // Deploy bundled skills to ~/.claude/skills/
 // Only installs if not already present — never overwrites user customizations.
@@ -750,16 +774,20 @@ const CAPABILITY_SECTIONS = [
   `"告诉X/让X" → \`~/.metame/bin/dispatch_to <project_key> "内容"\`，手机端 \`/dispatch to <key> <消息>\`。` + dispatchTable,
   '新增 Agent：`/agent bind <名称> <工作目录>`',
   '',
+  '## Agent 创建与管理',
+  '用户问创建/管理/绑定 Agent 时 → 先 `cat ~/.metame/docs/agent-guide.md` 再回答。',
+  '',
+  '## 手机端文件交互',
+  '用户要文件（"发给我"/"发过来"/"导出"）→ 先 `cat ~/.metame/docs/file-transfer.md` 再执行。',
+  '**收**：用户发图片/文件自动存到 `upload/`，用 Read 查看。',
+  '**发**：回复末尾加 `[[FILE:/absolute/path]]`，daemon 自动发手机。不要读内容再复述。',
+  '',
   '## 跨会话记忆',
   '用户提"上次/之前"时搜索：`node ~/.metame/memory-search.js "关键词1" "keyword2"`',
   '一次传 3-4 个关键词（中文+英文+函数名），`--facts` 只搜事实，`--sessions` 只搜会话。',
   '',
   '## Skills',
   '能力不足/工具缺失/任务失败 → 先查 `cat ~/.claude/skills/skill-manager/SKILL.md`，不要自己猜。',
-  '',
-  '## 手机端文件交互',
-  '**收**：用户发图片/文件自动存到 `upload/`，用 Read 查看。',
-  '**发**：回复末尾加 `[[FILE:/absolute/path]]`，daemon 自动发手机。不要读内容再复述。',
 
 ].join('\n');
 
@@ -778,6 +806,14 @@ try {
     ), '');
   }
 
+  // New user: seed with default template if CLAUDE.md is empty or missing
+  if (!globalContent.trim()) {
+    const tplPath = path.join(__dirname, 'scripts', 'templates', 'default-global-claude.md');
+    if (fs.existsSync(tplPath)) {
+      globalContent = fs.readFileSync(tplPath, 'utf8');
+    }
+  }
+
   const injection =
     GLOBAL_MARKER_START + '\n' +
     KERNEL_BODY + '\n\n' +

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.4.32",
+    "version": "1.4.34",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {

package/scripts/bin/dispatch_to

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+/**
+ * dispatch_to [--new] <project_key> "<prompt>"
+ * Tries Unix socket / Named Pipe first (low-latency), falls back to pending.jsonl.
+ */
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const net = require('net');
+const crypto = require('crypto');
+const os = require('os');
+const { socketPath } = require('../platform');
+
+const args = process.argv.slice(2);
+const newSession = args[0] === '--new' ? (args.shift(), true) : false;
+const [target, ...rest] = args;
+const prompt = rest.join(' ').replace(/^["']|["']$/g, '');
+if (!target || !prompt) {
+  console.error('Usage: dispatch_to [--new] <project_key> "<prompt>"');
+  process.exit(1);
+}
+
+const METAME_DIR = path.join(os.homedir(), '.metame');
+const DISPATCH_DIR = path.join(METAME_DIR, 'dispatch');
+const PENDING = path.join(DISPATCH_DIR, 'pending.jsonl');
+const DISPATCH_SECRET_FILE = path.join(METAME_DIR, '.dispatch_secret');
+const SOCK_PATH = socketPath(METAME_DIR);
+
+function getDispatchSecret() {
+  try {
+    if (fs.existsSync(DISPATCH_SECRET_FILE)) {
+      return fs.readFileSync(DISPATCH_SECRET_FILE, 'utf8').trim();
+    }
+  } catch { /* fall through to generate */ }
+  const secret = crypto.randomBytes(32).toString('hex');
+  try {
+    fs.writeFileSync(DISPATCH_SECRET_FILE, secret, { mode: 0o600 });
+  } catch { /* ignore write errors */ }
+  return secret;
+}
+
+const ts = new Date().toISOString();
+const secret = getDispatchSecret();
+const sigPayload = JSON.stringify({ target, prompt, 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 };
+
+function fallbackToFile() {
+  fs.mkdirSync(DISPATCH_DIR, { recursive: true });
+  fs.appendFileSync(PENDING, JSON.stringify(msg) + '\n');
+  console.log(`DISPATCH_OK(file): ${target} → ${prompt.slice(0, 60)}${newSession ? ' [new session]' : ''}`);
+}
+
+const sock = net.createConnection({ path: SOCK_PATH });
+let done = false;
+
+const timer = setTimeout(() => {
+  if (done) return;
+  done = true;
+  sock.destroy();
+  fallbackToFile();
+}, 2000);
+
+sock.on('connect', () => {
+  sock.write(JSON.stringify(msg));
+  sock.end();
+});
+
+sock.on('data', (data) => {
+  if (done) return;
+  done = true;
+  clearTimeout(timer);
+  try {
+    const res = JSON.parse(data.toString().trim());
+    if (res.ok) {
+      console.log(`DISPATCH_OK(socket): ${target} → ${prompt.slice(0, 60)}${newSession ? ' [new session]' : ''}`);
+    } else {
+      fallbackToFile();
+    }
+  } catch {
+    fallbackToFile();
+  }
+  sock.destroy();
+});
+
+sock.on('error', () => {
+  if (done) return;
+  done = true;
+  clearTimeout(timer);
+  fallbackToFile();
+});

package/scripts/daemon-claude-engine.js

@@ -653,41 +653,18 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
     }
 
     // Skill routing: detect skill first, then decide session
-    // BUT: if agent was explicitly addressed by nickname, don't let skill routing hijack the session
-    const skill = agentMatch ? null : routeSkill(prompt);
+    // BUT: skip skill routing if agent addressed by nickname OR chat already has an active session
+    // (active conversation should never be hijacked by keyword-based skill matching)
+    let session = getSession(chatId);
+    const hasActiveSession = session && session.started;
+    const skill = (agentMatch || hasActiveSession) ? null : routeSkill(prompt);
     const chatIdStr = String(chatId);
     const chatAgentMap = { ...(config.telegram ? config.telegram.chat_agent_map : {}), ...(config.feishu ? config.feishu.chat_agent_map : {}) };
     const boundProjectKey = chatAgentMap[chatIdStr] || projectKeyFromVirtualChatId(chatIdStr);
     const boundProject = boundProjectKey && config.projects ? config.projects[boundProjectKey] : null;
     const boundCwd = (boundProject && boundProject.cwd) ? normalizeCwd(boundProject.cwd) : null;
 
-    // Skills with dedicated pinned sessions (reused across days, no re-injection needed)
-    const PINNED_SKILL_SESSIONS = new Set(['skill-manager']);
-    const usePinnedSkillSession = !!(skill && PINNED_SKILL_SESSIONS.has(skill));
-
-    let session = getSession(chatId);
-
-    if (usePinnedSkillSession) {
-      // Use a dedicated long-lived session per skill
-      const state = loadState();
-      if (!state.pinned_sessions) state.pinned_sessions = {};
-      const pinned = state.pinned_sessions[skill];
-      if (pinned) {
-        // Reuse existing pinned session
-        state.sessions[chatId] = { id: pinned.id, cwd: pinned.cwd, started: true };
-        saveState(state);
-        session = state.sessions[chatId];
-        log('INFO', `Pinned session reused for skill ${skill}: ${pinned.id.slice(0, 8)}`);
-      } else {
-        // First time — create session and pin it
-        session = createSession(chatId, HOME, skill);
-        const st2 = loadState();
-        if (!st2.pinned_sessions) st2.pinned_sessions = {};
-        st2.pinned_sessions[skill] = { id: session.id, cwd: session.cwd };
-        saveState(st2);
-        log('INFO', `Pinned session created for skill ${skill}: ${session.id.slice(0, 8)}`);
-      }
-    } else if (!session) {
+    if (!session) {
       if (boundCwd) {
         // Agent-bound chats must stay in their own workspace: never attach to another project's session.
         const recentInBound = listRecentSessions(1, boundCwd);

package/scripts/daemon-task-scheduler.js

@@ -95,6 +95,23 @@ function nextClockRunAfter(schedule, fromMs) {
   return baseMs + 24 * 60 * 60 * 1000;
 }
 
+// Map short aliases and full model IDs to what Claude CLI accepts.
+// Claude CLI 2.x accepts both 'sonnet' and 'claude-sonnet-4-6'.
+// This normalization keeps daemon.yaml configs forward-compatible.
+const MODEL_ALIASES = {
+  haiku: 'claude-haiku-4-5-20251001',
+  sonnet: 'claude-sonnet-4-6',
+  opus: 'claude-opus-4-6',
+};
+
+function normalizeModel(raw) {
+  if (!raw || typeof raw !== 'string') return MODEL_ALIASES.haiku;
+  const lower = raw.trim().toLowerCase();
+  if (Object.prototype.hasOwnProperty.call(MODEL_ALIASES, lower)) return MODEL_ALIASES[lower];
+  // Already a full model ID (e.g. 'claude-sonnet-4-6') — pass through
+  return raw.trim();
+}
+
 function buildTaskSchedule(task, parseInterval) {
   const atRaw = typeof task.at === 'string' ? task.at.trim() : '';
   if (atRaw) {
@@ -358,7 +375,7 @@ function createTaskScheduler(deps) {
     }
 
     const preamble = buildProfilePreamble();
-    const model = task.model || 'haiku';
+    const model = normalizeModel(task.model || 'haiku');
     // If precondition returned context data, append it to the prompt
     let taskPrompt = task.prompt;
     if (precheck.context) {
@@ -533,7 +550,7 @@ function createTaskScheduler(deps) {
     const steps = task.steps || [];
     if (steps.length === 0) return { success: false, error: 'No steps defined', output: '' };
 
-    const model = task.model || 'sonnet';
+    const model = normalizeModel(task.model || 'sonnet');
     const cwd = task.cwd ? task.cwd.replace(/^~/, HOME) : HOME;
     const sessionId = crypto.randomUUID();
     const outputs = [];
@@ -686,12 +703,24 @@ function createTaskScheduler(deps) {
 
           if (runningTasks.has(task.name)) {
             // Task is still running; skip this cycle and keep full interval cadence.
-            nextRun[task.name] = nextRunAfter(schedule, currentTime);
+            try {
+              nextRun[task.name] = nextRunAfter(schedule, currentTime);
+            } catch (schedErr) {
+              nextRun[task.name] = currentTime + checkIntervalSec * 2 * 1000;
+              log('ERROR', `nextRunAfter (running guard) failed for "${task.name}": ${schedErr.message}`);
+            }
             log('WARN', `Task ${task.name} still running — skipping this interval`);
             continue;
           }
 
-          nextRun[task.name] = nextRunAfter(schedule, currentTime);
+          try {
+            nextRun[task.name] = nextRunAfter(schedule, currentTime);
+          } catch (schedErr) {
+            // If next-run calculation fails, back off by at least 2 ticks to prevent infinite loop
+            nextRun[task.name] = currentTime + checkIntervalSec * 2 * 1000;
+            log('ERROR', `nextRunAfter failed for "${task.name}": ${schedErr.message} — backing off`);
+            continue;
+          }
           runningTasks.add(task.name);
           // executeTask now returns a Promise (async, non-blocking, process-group kill)
           Promise.resolve(executeTask(task, config))

package/scripts/docs/agent-guide.md

@@ -0,0 +1,50 @@
+# Agent 创建与管理指南
+
+## 创建 Agent（完整流程）
+
+用户说"创建agent"、"新建agent"、"帮我建个agent"时，按此流程引导：
+
+### Step 1: 收集信息
+需要两个必要信息：
+- **工作目录**：Agent 的代码/项目目录（如 `~/projects/my-bot`）
+- **角色描述**（可选）：Agent 的职责定义
+
+如果用户没给目录，提示：
+> 请告诉我 Agent 的工作目录，例如 `~/projects/my-bot`
+
+### Step 2: 执行创建
+在手机端（飞书/Telegram），直接说即可，daemon 会自动处理：
+> 创建一个 Agent，目录是 ~/projects/my-bot
+
+在桌面 Claude Code 终端，需要手动操作：
+1. 创建项目目录和 CLAUDE.md（角色定义）
+2. 编辑 `~/.metame/daemon.yaml`，在 `projects` 下新增：
+   ```yaml
+   projects:
+     my_bot:
+       name: "我的机器人"
+       cwd: "~/projects/my-bot"
+       icon: "🤖"
+   ```
+3. 运行 `touch ~/.metame/daemon.js` 触发热重载
+
+### Step 3: 绑定群聊
+告知用户：
+> 请在飞书/Telegram 新建群组，把 bot 加进去，发送 `/activate` 完成绑定。
+
+`/activate` 会自动将群与最近创建的 Agent 绑定（30分钟内有效）。
+
+## 常用命令速查
+
+| 操作 | 手机端命令 |
+|------|-----------|
+| 新建 Agent | `/agent new` 或自然语言"创建agent" |
+| 绑定群 | `/activate` 或 `/agent bind <名称> [目录]` |
+| 查看列表 | `/agent list` |
+| 编辑角色 | `/agent edit` |
+| 解绑群 | `/agent unbind` |
+| 切换 Agent | 直接@昵称（仅非专属群） |
+
+## 注意事项
+- 专属群（chat_agent_map 中的群）永远绑定同一个 Agent，不能通过昵称切换
+- 新群必须发 `/activate` 才能使用，未授权群会提示"此群未授权"

package/scripts/docs/file-transfer.md

@@ -0,0 +1,32 @@
+# 文件传输协议
+
+## 用户要文件（发送到手机）
+
+当用户说"把xx发给我"、"文件发过来"、"发个截图"、"导出给我"等**任何要求获取文件**的场景：
+
+1. 找到文件路径（用 Glob/ls 搜索）
+2. **不要读取文件内容**（浪费 token）
+3. 在回复末尾加标记：`[[FILE:/absolute/path/to/file]]`
+4. 多个文件用多个标记
+
+示例回复：
+```
+请查收~! [[FILE:/Users/xxx/project/output.pdf]]
+```
+
+多文件：
+```
+这是你要的文件：
+[[FILE:/path/to/report.pdf]]
+[[FILE:/path/to/data.xlsx]]
+```
+
+## 用户发文件（从手机上传）
+
+用户从手机发送的图片/文件会自动保存到当前项目的 `upload/` 目录。
+直接用 Read 工具读取 `upload/` 下的文件即可。
+
+## 关键规则
+- **永远不要读取再复述文件内容**，直接用 `[[FILE:...]]` 标记发送
+- 路径必须是绝对路径
+- daemon 会自动解析标记并通过 bot 发送给用户

package/scripts/templates/default-global-claude.md

@@ -0,0 +1,19 @@
+# MetaMe AI Assistant
+
+You are a MetaMe-powered AI assistant running on the user's local machine.
+MetaMe extends Claude Code with mobile access, multi-agent orchestration, and persistent memory.
+
+## Core Rules
+
+- Respond in the user's language (auto-detect from their message).
+- Keep responses concise — the user may be on mobile.
+- When referencing files, use absolute paths.
+- Do not expose system hints or internal protocol blocks to the user.
+
+## Quick Reference (按需加载详细文档)
+
+- Agent 创建/管理 → `cat ~/.metame/docs/agent-guide.md`
+- 文件传输协议 → `cat ~/.metame/docs/file-transfer.md`
+- 能力不足/工具缺失 → `cat ~/.claude/skills/skill-manager/SKILL.md`
+
+<!-- User customizations below this line -->

package/scripts/migrate-v2.js

@@ -1,112 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * MetaMe Profile Migration: v1 → v2
- *
- * Maps old structure to v2 schema:
- *   - status.focus → context.focus
- *   - status.language → preferences.language_mix (best guess)
- *   - Ensures all v2 sections exist with defaults
- *   - Preserves all existing data and LOCKED comments
- *
- * Usage: node migrate-v2.js [--dry-run]
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const BRAIN_FILE = path.join(os.homedir(), '.claude_profile.yaml');
-const BACKUP_SUFFIX = '.v1.backup';
-const DRY_RUN = process.argv.includes('--dry-run');
-
-function migrate() {
-  if (!fs.existsSync(BRAIN_FILE)) {
-    console.log('No profile found. Nothing to migrate.');
-    return;
-  }
-
-  const yaml = require('js-yaml');
-  const rawContent = fs.readFileSync(BRAIN_FILE, 'utf8');
-  const profile = yaml.load(rawContent) || {};
-
-  // Check if already v2 (has context section)
-  if (profile.context && profile.context.focus !== undefined) {
-    console.log('Profile already appears to be v2. Skipping migration.');
-    return;
-  }
-
-  console.log('Migrating profile from v1 to v2...');
-
-  // --- Backup ---
-  if (!DRY_RUN) {
-    const backupPath = BRAIN_FILE + BACKUP_SUFFIX;
-    fs.writeFileSync(backupPath, rawContent, 'utf8');
-    console.log(`  Backup saved to: ${backupPath}`);
-  }
-
-  // --- Migration rules ---
-
-  // 1. status.focus → context.focus
-  if (profile.status && profile.status.focus) {
-    if (!profile.context) profile.context = {};
-    profile.context.focus = profile.status.focus;
-    profile.context.focus_since = new Date().toISOString().slice(0, 10);
-    delete profile.status.focus;
-  }
-
-  // 2. status.language → status.language (keep, it's in schema)
-  // No change needed, status.language is valid in v2
-
-  // 3. Clean up empty status object
-  if (profile.status && Object.keys(profile.status).length === 0) {
-    delete profile.status;
-  }
-
-  // 4. Ensure context section exists with defaults
-  if (!profile.context) profile.context = {};
-  if (profile.context.focus === undefined) profile.context.focus = null;
-  if (profile.context.focus_since === undefined) profile.context.focus_since = null;
-  if (profile.context.active_projects === undefined) profile.context.active_projects = [];
-  if (profile.context.blockers === undefined) profile.context.blockers = [];
-  if (profile.context.energy === undefined) profile.context.energy = null;
-
-  // 5. Ensure evolution section exists
-  if (!profile.evolution) profile.evolution = {};
-  if (profile.evolution.last_distill === undefined) profile.evolution.last_distill = null;
-  if (profile.evolution.distill_count === undefined) profile.evolution.distill_count = 0;
-  if (profile.evolution.recent_changes === undefined) profile.evolution.recent_changes = [];
-
-  // 6. Ensure preferences section exists (don't overwrite existing values)
-  if (!profile.preferences) profile.preferences = {};
-
-  // --- Output ---
-  const dumped = yaml.dump(profile, { lineWidth: -1 });
-
-  // Restore LOCKED comments from original
-  const lockedLines = rawContent.split('\n').filter(l => l.includes('# [LOCKED]'));
-  let restored = dumped;
-  for (const lockedLine of lockedLines) {
-    const match = lockedLine.match(/^\s*([\w_]+)\s*:\s*(.+?)\s+(#.+)$/);
-    if (match) {
-      const key = match[1];
-      const comment = match[3];
-      // Find the corresponding line in dumped output and append comment
-      restored = restored.replace(
-        new RegExp(`^(\\s*${key}\\s*:.+)$`, 'm'),
-        (line) => line.includes('#') ? line : `${line} ${comment}`
-      );
-    }
-  }
-
-  if (DRY_RUN) {
-    console.log('\n--- DRY RUN (would write): ---');
-    console.log(restored);
-    console.log('--- END DRY RUN ---');
-  } else {
-    fs.writeFileSync(BRAIN_FILE, restored, 'utf8');
-    console.log('  Migration complete. Profile is now v2.');
-  }
-}
-
-migrate();

package/scripts/self-reflect.js

@@ -1,285 +0,0 @@
-#!/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');
-      } catch {
-        // Another process acquired the lock
-        return;
-      }
-      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),
-        // 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 };