metame-cli 1.3.18 → 1.3.20

package/README.md

@@ -54,6 +54,10 @@
 * **🏥 Emergency Recovery (v1.3.13):** `/doctor` interactive diagnostics with one-tap fix buttons, `/sh` direct shell access from your phone (bypasses Claude entirely — the lifeline when everything else is broken), automatic config backup before any setting change, `/fix` to restore last known good config. `/model` interactive model switcher with auto-backup.
 * **🌐 Browser Automation (v1.3.15):** Native Playwright MCP integration — auto-registered on first run. Every MetaMe user gets browser control capability out of the box. Combined with Skills, enables workflows like automated podcast publishing, form filling, and web scraping.
 * **📂 Interactive File Browser (v1.3.15):** `/list` shows clickable button cards — folders expand inline, files download on tap. Folder buttons survive daemon restarts (absolute paths, no expiry). Zero token cost.
+* **🔀 Parallel Multi-Agent Chats (v1.3.19):** Assign each agent its own dedicated Feishu/Telegram group. Messages in different groups execute in parallel — no waiting for each other. Route `chatId → agent` via `chat_agent_map` in `daemon.yaml`. Create a new group, send `/bind <name>` to register it instantly.
+* **🔧 Config Hot-Reload Fix (v1.3.19):** `allowed_chat_ids` is now read dynamically on every message — no restart needed after editing `daemon.yaml`. `/fix` config restore now merges current `chatId` settings so manually-added groups are never lost.
+* **🛡️ Daemon Auto-Restart via LaunchAgent (v1.3.19):** MetaMe's npm daemon is now managed by macOS launchd. Crashes or unexpected exits trigger an automatic restart after 5 seconds.
+* **👥 Operator Permissions & Read-Only Mode (v1.3.19):** Add `operator_ids` to restrict who can execute Claude commands in shared groups. Non-operators can still chat and query (read/search/web only) — they just can't edit files, run bash, or trigger slash commands. Use `/myid` to discover any user's Feishu open_id.
 
 ## 🛠 Prerequisites
 
@@ -341,6 +345,9 @@ Bot: 回退到哪一轮？
 | `/budget` | Today's token usage |
 | `/quiet` | Silence mirror/reflections for 48h |
 | `/reload` | Manually reload daemon.yaml (also auto-reloads on file change) |
+| `/bind <name>` | Register current group as a dedicated agent chat — opens directory browser to pick working directory |
+| `/chatid` | Show the current group's chat ID |
+| `/myid` | Show your own Feishu sender open_id (for configuring `operator_ids`) |
 
 **Heartbeat Tasks:**
 
@@ -395,6 +402,7 @@ Each step runs in the same Claude Code session. Step outputs automatically becom
 **Security:**
 
 * `allowed_chat_ids` whitelist — unauthorized users silently ignored (empty = deny all)
+* `operator_ids` — within an allowed group, restrict command execution to specific users; non-operators get read-only chat mode
 * `dangerously_skip_permissions` enabled by default for mobile (users can't click "allow" on phone — security relies on the chat ID whitelist)
 * `~/.metame/` directory set to mode 700
 * Bot tokens stored locally, never transmitted
@@ -446,6 +454,74 @@ projects:
 
 **Heartbeat task notifications** arrive as colored Feishu cards — each project's color is distinct, so you can tell at a glance which agent sent the update.
 
+### Parallel Multi-Agent Chats & `/bind` Command (v1.3.19)
+
+Give each agent its own dedicated group chat — messages to different groups execute simultaneously without blocking each other.
+
+**How it works:**
+
+Each group is mapped to a specific agent via `chat_agent_map` in `daemon.yaml`. When a message arrives in a group, the daemon looks up which agent owns that `chatId` and dispatches the Claude call to that agent's working directory — fully parallel.
+
+**Setup — `/bind` command (recommended):**
+
+1. Create a new Feishu or Telegram group and add your bot.
+2. In the group, send `/bind <name>` (e.g., `/bind backend`).
+3. The bot opens a Finder-style directory browser — tap folders to navigate, tap a folder name to select it as the working directory.
+4. Done. The bot automatically:
+   - Adds the group's `chatId` to `allowed_chat_ids`
+   - Creates a `chat_agent_map` entry routing this group to the agent
+   - Creates a `projects` entry for the agent
+   - Sends a welcome card
+
+> **No whitelist required:** `/bind` works in any group — the new group self-registers without needing to be pre-approved in `allowed_chat_ids`.
+
+> **Re-binding:** Send `/bind <name>` again in the same group to overwrite the previous configuration.
+
+**Manual setup** (`~/.metame/daemon.yaml`):
+
+```yaml
+chat_agent_map:
+  "oc_abc123": "backend"          # chatId → project key
+  "oc_def456": "frontend"
+
+projects:
+  backend:
+    name: "Backend API"
+    cwd: "~/projects/api"
+  frontend:
+    name: "Frontend App"
+    cwd: "~/projects/app"
+```
+
+**`/chatid` command:**
+
+In any authorized group, send `/chatid` and the bot replies with the current group's `chatId`. Useful for manual configuration.
+
+| Command | Description |
+|---------|-------------|
+| `/bind <name>` | Register current group as a dedicated agent chat — opens directory browser to pick working directory |
+| `/chatid` | Show the current group's chat ID |
+| `/myid` | Show your own Feishu sender open_id |
+
+**Operator Permissions (`operator_ids`):**
+
+In shared groups (e.g., a group with a colleague or tester), you can restrict who can execute Claude commands. Non-operators get a read-only chat mode — they can ask questions and search, but can't edit files, run bash, or trigger slash commands.
+
+```yaml
+feishu:
+  operator_ids:
+    - "ou_abc123yourid"   # Only these users can execute commands
+```
+
+Use `/myid` in any Feishu group to get a user's open_id. Then add it to `operator_ids` to grant full access.
+
+| User type | Chat & query | Slash commands | Write / Edit / Bash |
+|-----------|:---:|:---:|:---:|
+| Operator | ✅ | ✅ | ✅ |
+| Non-operator | ✅ | ❌ | ❌ |
+
+> If `operator_ids` is empty, all whitelisted users have full access (default behavior).
+
 ### Provider Relay — Third-Party Model Support (v1.3.11)
 
 MetaMe supports any Anthropic-compatible API relay as a backend. This means you can route Claude Code through a third-party relay that maps `sonnet`/`opus`/`haiku` to any model (GPT-4, DeepSeek, Gemini, etc.) — MetaMe passes standard model names and the relay handles translation.
@@ -649,6 +725,7 @@ A: No. Your profile stays local at `~/.claude_profile.yaml`. MetaMe simply passe
 
 | Version | Highlights |
 |---------|------------|
+| **v1.3.19** | **Parallel multi-agent group chats** — `chat_agent_map` routes chatId → agent for true parallel execution; `/bind` command for one-tap group registration with Finder-style directory browser; `/chatid` to look up group ID; `allowed_chat_ids` hot-reload fix (read per message, no restart); `/fix` now merges current chatId config; daemon auto-restart via macOS LaunchAgent (5-second recovery); **operator_ids** permission layer — non-operators get read-only chat mode (query/search, no write/execute); `/myid` command to retrieve Feishu open_id |
 | **v1.3.18** | **Multi-agent project isolation** — `projects` in `daemon.yaml` with per-project heartbeat tasks, Feishu colored cards per project, `/agent` picker button, nickname routing (say agent name to switch instantly), reply-to-message session restoration, fix `~` expansion in project cwd |
 | **v1.3.17** | **Windows support** (WSL one-command installer), `install-systemd` for Linux/WSL daemon auto-start. Fix onboarding (Genesis interview was never injected, CLAUDE.md accumulated across runs). Marker-based cleanup, unified protocols, `--append-system-prompt` guarantees interview activation, Feishu auto-fetch chat ID, full mobile permissions, fix `/publish` false-success, auto-restart daemon on script update |
 | **v1.3.16** | Git-based `/undo` (auto-checkpoint before each turn, `git reset --hard` rollback), `/nosleep` toggle (macOS caffeinate), custom provider model passthrough (`/model` accepts any name for non-anthropic providers), auto-fallback to anthropic/opus on provider failure, message queue works on Telegram (fire-and-forget poll loop), lazy background distill |

package/index.js

@@ -203,6 +203,21 @@ function spawnDistillBackground() {
     } catch { /* stale lock, proceed */ }
   }
 
+  // 4-hour cooldown: check last distill timestamp from profile
+  const cooldownMs = 4 * 60 * 60 * 1000;
+  try {
+    const profilePath = path.join(process.env.HOME || '', '.claude_profile.yaml');
+    if (fs.existsSync(profilePath)) {
+      const yaml = require('js-yaml');
+      const profile = yaml.load(fs.readFileSync(profilePath, 'utf8'));
+      const distillLog = profile && profile.evolution && profile.evolution.auto_distill;
+      if (Array.isArray(distillLog) && distillLog.length > 0) {
+        const lastTs = new Date(distillLog[distillLog.length - 1].ts).getTime();
+        if (Date.now() - lastTs < cooldownMs) return;
+      }
+    }
+  } catch { /* non-fatal, proceed */ }
+
   const hasSignals = shouldDistill();
   const bootstrap = needsBootstrap();
 
@@ -305,7 +320,7 @@ runExpiryCleanup();
 if (!fs.existsSync(BRAIN_FILE)) {
   const initialProfile = `identity:
   role: Unknown
-  nickname: null
+  locale: null
 status:
   focus: Initializing
 `;
@@ -367,12 +382,12 @@ You are entering **Calibration Mode**. You are not a chatbot; you are a Psycholo
 
 5. **Shadows (Hidden Fears):** What are you avoiding? What pattern do you keep repeating? What keeps you up at night?
 
-6. **Identity (Nickname + Role):** Based on everything learned, propose a nickname and role summary. Ask if it resonates.
+6. **Identity (Role + Locale):** Based on everything learned, propose a role summary and confirm their preferred language (locale). Ask if it resonates.
 
 **TERMINATION:**
 - After 5-7 exchanges, synthesize everything into \`~/.claude_profile.yaml\`.
 - **LOCK** Core Values with \`# [LOCKED]\`.
-- Announce: "Link Established. I see you now, [Nickname]."
+- Announce: "Link Established. Profile calibrated."
 - Then proceed to **Phase 2** below.
 
 **3. SETUP WIZARD (Phase 2 — Optional):**
@@ -440,7 +455,7 @@ let isKnownUser = false;
 try {
   if (fs.existsSync(BRAIN_FILE)) {
     const doc = yaml.load(fs.readFileSync(BRAIN_FILE, 'utf8')) || {};
-    if (doc.identity && doc.identity.nickname && doc.identity.nickname !== 'null') {
+    if (doc.identity && doc.identity.locale && doc.identity.locale !== 'null') {
       isKnownUser = true;
     }
   }

package/package.json

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

package/scripts/daemon.js

@@ -126,12 +126,34 @@ function backupConfig() {
 
 function restoreConfig() {
   const bak = CONFIG_FILE + '.bak';
-  if (fs.existsSync(bak)) {
+  if (!fs.existsSync(bak)) return false;
+  try {
+    const bakCfg = yaml.load(fs.readFileSync(bak, 'utf8')) || {};
+    // Preserve security-critical fields from current config (chat IDs, agent map)
+    // so a /fix never loses manually-added channels
+    let curCfg = {};
+    try { curCfg = yaml.load(fs.readFileSync(CONFIG_FILE, 'utf8')) || {}; } catch {}
+    for (const adapter of ['feishu', 'telegram']) {
+      if (curCfg[adapter] && bakCfg[adapter]) {
+        const curIds = curCfg[adapter].allowed_chat_ids || [];
+        const bakIds = bakCfg[adapter].allowed_chat_ids || [];
+        // Union of both lists
+        const merged = [...new Set([...bakIds, ...curIds])];
+        bakCfg[adapter].allowed_chat_ids = merged;
+        // Merge chat_agent_map (current takes precedence)
+        bakCfg[adapter].chat_agent_map = Object.assign(
+          {}, bakCfg[adapter].chat_agent_map || {}, curCfg[adapter].chat_agent_map || {}
+        );
+      }
+    }
+    fs.writeFileSync(CONFIG_FILE, yaml.dump(bakCfg, { lineWidth: -1 }), 'utf8');
+    config = loadConfig();
+    return true;
+  } catch {
     fs.copyFileSync(bak, CONFIG_FILE);
     config = loadConfig();
     return true;
   }
-  return false;
 }
 
 let _cachedState = null;
@@ -554,7 +576,7 @@ async function startTelegramBridge(config, executeTaskByName) {
 
   const { createBot } = require(path.join(__dirname, 'telegram-adapter.js'));
   const bot = createBot(config.telegram.bot_token);
-  const allowedIds = config.telegram.allowed_chat_ids || [];
+  // allowedIds read dynamically per-message to support hot-reload of daemon.yaml
 
   // Verify bot
   try {
@@ -581,6 +603,7 @@ async function startTelegramBridge(config, executeTaskByName) {
             const chatId = cb.message && cb.message.chat.id;
             bot.answerCallback(cb.id).catch(() => {});
             if (chatId && cb.data) {
+              const allowedIds = (loadConfig().telegram && loadConfig().telegram.allowed_chat_ids) || [];
               if (!allowedIds.includes(chatId)) continue;
               // Fire-and-forget: don't block poll loop (enables message queue)
               handleCommand(bot, chatId, cb.data, config, executeTaskByName).catch(e => {
@@ -595,8 +618,11 @@ async function startTelegramBridge(config, executeTaskByName) {
           const msg = update.message;
           const chatId = msg.chat.id;
 
-          // Security: check whitelist (empty = deny all)
-          if (!allowedIds.includes(chatId)) {
+          // Security: check whitelist (empty = deny all) — read live config to support hot-reload
+          // Exception: /bind is allowed from any chat so users can self-register new groups
+          const allowedIds = (loadConfig().telegram && loadConfig().telegram.allowed_chat_ids) || [];
+          const isBindCmd = msg.text && msg.text.trim().startsWith('/bind');
+          if (!allowedIds.includes(chatId) && !isBindCmd) {
             log('WARN', `Rejected message from unauthorized chat: ${chatId}`);
             continue;
           }
@@ -670,9 +696,15 @@ async function startTelegramBridge(config, executeTaskByName) {
   };
 }
 
+// ── Timing constants ─────────────────────────────────────────────────────────
+const CLAUDE_COOLDOWN_MS  = 10000; // 10s between Claude calls per chat
+const STATUS_THROTTLE_MS  = 3000;  // Min 3s between streaming status updates
+const FALLBACK_THROTTLE_MS = 8000; // 8s between fallback status updates
+const DEDUP_TTL_MS        = 60000; // Feishu message dedup window (60s)
+// ─────────────────────────────────────────────────────────────────────────────
+
 // Rate limiter for /ask and /run — prevents rapid-fire Claude calls
 const _lastClaudeCall = {};
-const CLAUDE_COOLDOWN_MS = 10000; // 10s between Claude calls per chat
 
 function checkCooldown(chatId) {
   const now = Date.now();
@@ -688,63 +720,126 @@ function checkCooldown(chatId) {
 // Path shortener — imported from ./utils
 const { shortenPath, expandPath } = createPathMap();
 
+/**
+ * Normalize a directory path: expand shortcuts and resolve ~
+ */
+function normalizeCwd(p) {
+  return expandPath(p).replace(/^~/, HOME);
+}
+
+/**
+ * Parse [[FILE:...]] markers from Claude output.
+ * Returns { markedFiles, cleanOutput }
+ */
+function parseFileMarkers(output) {
+  const markers = output.match(/\[\[FILE:([^\]]+)\]\]/g) || [];
+  const markedFiles = markers.map(m => m.match(/\[\[FILE:([^\]]+)\]\]/)[1].trim());
+  const cleanOutput = output.replace(/\s*\[\[FILE:[^\]]+\]\]/g, '').trim();
+  return { markedFiles, cleanOutput };
+}
+
+/**
+ * Merge explicit [[FILE:...]] paths with auto-detected content files.
+ * Returns a Set of unique file paths.
+ */
+function mergeFileCollections(markedFiles, sourceFiles) {
+  const result = new Set(markedFiles);
+  if (sourceFiles && sourceFiles.length > 0) {
+    for (const f of sourceFiles) { if (isContentFile(f)) result.add(f); }
+  }
+  return result;
+}
+
+/**
+ * Send file download buttons for a set of file paths.
+ */
+async function sendFileButtons(bot, chatId, files) {
+  if (!bot.sendButtons || files.size === 0) return;
+  const validFiles = [...files].filter(f => fs.existsSync(f));
+  if (validFiles.length === 0) return;
+  const buttons = validFiles.map(filePath => {
+    const shortId = cacheFile(filePath);
+    return [{ text: `📎 ${path.basename(filePath)}`, callback_data: `/file ${shortId}` }];
+  });
+  await bot.sendButtons(chatId, '📂 文件:', buttons);
+}
+
+/**
+ * Attach chatId to the most recent session in projCwd, or create a new one.
+ */
+function attachOrCreateSession(chatId, projCwd, name) {
+  const state = loadState();
+  const recent = listRecentSessions(1, projCwd);
+  if (recent.length > 0 && recent[0].sessionId) {
+    state.sessions[chatId] = { id: recent[0].sessionId, cwd: projCwd, started: true };
+  } else {
+    const newSess = createSession(chatId, projCwd, name || '');
+    state.sessions[chatId] = { id: newSess.id, cwd: projCwd, started: false };
+  }
+  saveState(state);
+}
+
 /**
  * Send directory picker: recent projects + Browse button
  * @param {string} mode - 'new' or 'cd' (determines callback command)
  */
 async function sendDirPicker(bot, chatId, mode, title) {
-  const dirs = listProjectDirs();
-  const cmd = mode === 'new' ? '/new' : '/cd';
-  if (bot.sendButtons) {
-    const buttons = dirs.map(d => [{ text: d.label, callback_data: `${cmd} ${shortenPath(d.path)}` }]);
-    buttons.push([{ text: 'Browse...', callback_data: `/browse ${mode} ${shortenPath(HOME)}` }]);
-    await bot.sendButtons(chatId, title, buttons);
-  } else {
-    let msg = `${title}\n`;
-    dirs.forEach((d, i) => { msg += `${i + 1}. ${d.label}\n   ${cmd} ${d.path}\n`; });
-    msg += `\nOr type: ${cmd} /full/path`;
-    await bot.sendMessage(chatId, msg);
-  }
+  // Always open the file browser starting from HOME — Finder-style navigation
+  await sendBrowse(bot, chatId, mode, HOME, title);
 }
 
 /**
- * Send directory browser: list subdirs of a path with .. parent nav
+ * Send directory browser: Finder-style navigation
+ * - Clicking a subdir ALWAYS navigates into it (never immediate select)
+ * - "✓ 选择此目录" button at top confirms the current dir
+ * - Shows up to 12 subdirs per page with pagination
  */
-async function sendBrowse(bot, chatId, mode, dirPath) {
-  const cmd = mode === 'new' ? '/new' : '/cd';
+async function sendBrowse(bot, chatId, mode, dirPath, title, page = 0) {
+  const cmd = mode === 'new' ? '/new' : mode === 'bind' ? '/bind-dir' : '/cd';
+  const PAGE_SIZE = 10;
   try {
     const entries = fs.readdirSync(dirPath, { withFileTypes: true });
     const subdirs = entries
       .filter(e => e.isDirectory() && !e.name.startsWith('.'))
       .map(e => e.name)
-      .sort()
-      .slice(0, 8); // max 8 subdirs per screen
+      .sort();
+
+    const totalPages = Math.ceil(subdirs.length / PAGE_SIZE);
+    const pageSubdirs = subdirs.slice(page * PAGE_SIZE, (page + 1) * PAGE_SIZE);
+    const parent = path.dirname(dirPath);
+    const displayPath = dirPath.replace(HOME, '~');
 
     if (bot.sendButtons) {
       const buttons = [];
-      // Select this directory
-      buttons.push([{ text: `>> Use this dir`, callback_data: `${cmd} ${shortenPath(dirPath)}` }]);
-      // Subdirectories
-      for (const name of subdirs) {
+      // ✓ Confirm current dir
+      buttons.push([{ text: `✓ 选择「${displayPath}」`, callback_data: `${cmd} ${shortenPath(dirPath)}` }]);
+      // Subdirectories — click = navigate in
+      for (const name of pageSubdirs) {
         const full = path.join(dirPath, name);
-        buttons.push([{ text: `${name}/`, callback_data: `/browse ${mode} ${shortenPath(full)}` }]);
+        buttons.push([{ text: `📁 ${name}`, callback_data: `/browse ${mode} ${shortenPath(full)}` }]);
       }
-      // Parent
-      const parent = path.dirname(dirPath);
+      // Pagination
+      const nav = [];
+      if (page > 0) nav.push({ text: '← 上页', callback_data: `/browse ${mode} ${shortenPath(dirPath)} ${page - 1}` });
+      if (page < totalPages - 1) nav.push({ text: '下页 →', callback_data: `/browse ${mode} ${shortenPath(dirPath)} ${page + 1}` });
+      if (nav.length) buttons.push(nav);
+      // Parent dir
       if (parent !== dirPath) {
-        buttons.push([{ text: '.. back', callback_data: `/browse ${mode} ${shortenPath(parent)}` }]);
+        buttons.push([{ text: '⬆ 上级目录', callback_data: `/browse ${mode} ${shortenPath(parent)}` }]);
       }
-      await bot.sendButtons(chatId, dirPath, buttons);
+      const header = title ? `${title}\n📂 ${displayPath}` : `📂 ${displayPath}`;
+      await bot.sendButtons(chatId, header, buttons);
     } else {
-      let msg = `${dirPath}\n\n`;
-      subdirs.forEach((name, i) => {
-        msg += `${i + 1}. ${name}/\n   /browse ${mode} ${path.join(dirPath, name)}\n`;
+      let msg = `📂 ${displayPath}\n\n`;
+      pageSubdirs.forEach((name, i) => {
+        msg += `${page * PAGE_SIZE + i + 1}. ${name}/\n   /browse ${mode} ${path.join(dirPath, name)}\n`;
       });
-      msg += `\nSelect: ${cmd} ${dirPath}\nBack: /browse ${mode} ${path.dirname(dirPath)}`;
+      msg += `\n✓ 选择此目录: ${cmd} ${dirPath}`;
+      if (parent !== dirPath) msg += `\n⬆ 上级: /browse ${mode} ${parent}`;
       await bot.sendMessage(chatId, msg);
     }
   } catch (e) {
-    await bot.sendMessage(chatId, `Cannot read: ${dirPath}`);
+    await bot.sendMessage(chatId, `无法读取目录: ${dirPath}`);
   }
 }
 
@@ -851,16 +946,132 @@ async function sendDirListing(bot, chatId, baseDir, arg) {
 /**
  * Unified command handler — shared by Telegram & Feishu
  */
-async function handleCommand(bot, chatId, text, config, executeTaskByName) {
+
+async function doBindAgent(bot, chatId, agentName, agentCwd) {
+  // /bind sets the session context (cwd, CLAUDE.md, project configs) for this chat.
+  // 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).
+  try {
+    const cfg = loadConfig();
+    const isTg = typeof chatId === 'number';
+    const ak = isTg ? 'telegram' : 'feishu';
+    if (!cfg[ak]) cfg[ak] = {};
+    if (!cfg[ak].allowed_chat_ids) cfg[ak].allowed_chat_ids = [];
+    if (!cfg[ak].chat_agent_map) cfg[ak].chat_agent_map = {};
+    const idVal = isTg ? chatId : String(chatId);
+    if (!cfg[ak].allowed_chat_ids.includes(idVal)) cfg[ak].allowed_chat_ids.push(idVal);
+    const projectKey = agentName.replace(/[^a-zA-Z0-9_]/g, '_').toLowerCase() || String(chatId);
+    cfg[ak].chat_agent_map[String(chatId)] = projectKey;
+    if (!cfg.projects) cfg.projects = {};
+    const isNew = !cfg.projects[projectKey];
+    if (isNew) {
+      cfg.projects[projectKey] = { name: agentName, cwd: agentCwd, nicknames: [agentName] };
+    } else {
+      cfg.projects[projectKey].name = agentName;
+      cfg.projects[projectKey].cwd = agentCwd;
+    }
+    fs.writeFileSync(CONFIG_FILE, yaml.dump(cfg, { lineWidth: -1 }), 'utf8');
+    backupConfig();
+
+    const proj = cfg.projects[projectKey];
+    const icon = proj.icon || '🤖';
+    const color = proj.color || 'blue';
+    const action = isNew ? '绑定成功' : '重新绑定';
+    const displayCwd = agentCwd.replace(HOME, '~');
+    if (bot.sendCard) {
+      await bot.sendCard(chatId, {
+        title: `${icon} ${agentName} — ${action}`,
+        body: `**工作目录**\n${displayCwd}\n\n直接发消息即可开始对话，无需 @bot`,
+        color,
+      });
+    } else {
+      await bot.sendMessage(chatId, `${icon} ${agentName} ${action}\n目录: ${displayCwd}`);
+    }
+  } catch (e) {
+    await bot.sendMessage(chatId, `❌ 绑定失败: ${e.message}`);
+  }
+}
+
+async function handleCommand(bot, chatId, text, config, executeTaskByName, senderId = null, readOnly = false) {
   const state = loadState();
 
+  // --- /chatid: reply with current chatId ---
+  if (text === '/chatid') {
+    await bot.sendMessage(chatId, `Chat ID: \`${chatId}\``);
+    return;
+  }
+
+  // --- /myid: reply with sender's user open_id (for configuring operator_ids) ---
+  if (text === '/myid') {
+    await bot.sendMessage(chatId, senderId ? `Your ID: \`${senderId}\`` : 'ID not available (Telegram not supported)');
+    return;
+  }
+
+  // --- /bind <name> [cwd]: register this chat as a dedicated agent channel ---
+  // With cwd:    /bind 小美 ~/          → bind immediately
+  // Without cwd: /bind 教授             → show directory picker
+  if (text.startsWith('/bind ') || text === '/bind') {
+    const args = text.slice(5).trim();
+    const parts = args.split(/\s+/);
+    const agentName = parts[0];
+    const agentCwd = parts.slice(1).join(' ');
+
+    if (!agentName) {
+      await bot.sendMessage(chatId, '用法: /bind <名称> [工作目录]\n例: /bind 小美 ~/\n或:  /bind 教授  (弹出目录选择)');
+      return;
+    }
+
+    if (!agentCwd) {
+      // No cwd given — show directory picker
+      pendingBinds.set(String(chatId), agentName);
+      await sendDirPicker(bot, chatId, 'bind', `为「${agentName}」选择工作目录:`);
+      return;
+    }
+
+    await doBindAgent(bot, chatId, agentName, agentCwd);
+    return;
+  }
+
+  // --- /bind-dir <path>: called by directory picker to complete a pending bind ---
+  if (text.startsWith('/bind-dir ')) {
+    const dirPath = expandPath(text.slice(10).trim());
+    const agentName = pendingBinds.get(String(chatId));
+    if (!agentName) {
+      await bot.sendMessage(chatId, '❌ 没有待完成的 /bind，请重新发送 /bind <名称>');
+      return;
+    }
+    pendingBinds.delete(String(chatId));
+    await doBindAgent(bot, chatId, agentName, dirPath);
+    return;
+  }
+
+  // --- chat_agent_map: auto-switch agent based on dedicated chatId ---
+  // Configure in daemon.yaml: feishu.chat_agent_map or telegram.chat_agent_map
+  //   e.g.  chat_agent_map: { "oc_xxx": "personal", "oc_yyy": "metame" }
+  const chatAgentMap = (config.feishu && config.feishu.chat_agent_map) ||
+                       (config.telegram && config.telegram.chat_agent_map) || {};
+  const mappedKey = chatAgentMap[String(chatId)];
+  if (mappedKey && config.projects && config.projects[mappedKey]) {
+    const proj = config.projects[mappedKey];
+    const projCwd = normalizeCwd(proj.cwd);
+    const cur = loadState().sessions?.[chatId];
+    if (!cur || cur.cwd !== projCwd) {
+      attachOrCreateSession(chatId, projCwd, proj.name || mappedKey);
+    }
+  }
+
   // --- Browse handler (directory navigation) ---
   if (text.startsWith('/browse ')) {
     const parts = text.slice(8).trim().split(' ');
-    const mode = parts[0]; // 'new' or 'cd'
-    const dirPath = expandPath(parts.slice(1).join(' '));
+    const mode = parts[0]; // 'new', 'cd', or 'bind'
+    // Last token may be a page number
+    const lastPart = parts[parts.length - 1];
+    const page = /^\d+$/.test(lastPart) ? parseInt(lastPart, 10) : 0;
+    const pathParts = /^\d+$/.test(lastPart) ? parts.slice(1, -1) : parts.slice(1);
+    const dirPath = expandPath(pathParts.join(' '));
     if (mode && dirPath && fs.existsSync(dirPath)) {
-      await sendBrowse(bot, chatId, mode, dirPath);
+      await sendBrowse(bot, chatId, mode, dirPath, null, page);
     } else if (/^p\d+$/.test(dirPath)) {
       await bot.sendMessage(chatId, '⚠️ Button expired. Pick again:');
       await sendDirPicker(bot, chatId, mode || 'cd', 'Switch workdir:');
@@ -875,6 +1086,19 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
   if (text === '/new' || text.startsWith('/new ')) {
     const arg = text.slice(4).trim();
     if (!arg) {
+      // In a dedicated agent group, use the agent's bound cwd directly
+      const newCfg = loadConfig();
+      const agentMap = (newCfg.feishu && newCfg.feishu.chat_agent_map) ||
+                       (newCfg.telegram && newCfg.telegram.chat_agent_map) || {};
+      const boundKey = agentMap[String(chatId)];
+      const boundProj = boundKey && newCfg.projects && newCfg.projects[boundKey];
+      if (boundProj && boundProj.cwd) {
+        const boundCwd = normalizeCwd(boundProj.cwd);
+        const session = createSession(chatId, boundCwd, '');
+        await bot.sendMessage(chatId, `✅ 新会话已创建\nWorkdir: ${session.cwd}`);
+        return;
+      }
+      // Non-dedicated group: show directory picker
       await sendDirPicker(bot, chatId, 'new', 'Pick a workdir:');
       return;
     }
@@ -1128,7 +1352,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
     const currentSession = getSession(chatId);
     const currentCwd = currentSession?.cwd ? path.resolve(expandPath(currentSession.cwd)) : null;
     const buttons = entries.map(([key, p]) => {
-      const projCwd = expandPath(p.cwd).replace(/^~/, HOME);
+      const projCwd = normalizeCwd(p.cwd);
       const active = currentCwd && path.resolve(projCwd) === currentCwd ? ' ◀' : '';
       return [{ text: `${p.icon || '🤖'} ${p.name || key}${active}`, callback_data: `/cd ${projCwd}` }];
     });
@@ -1940,7 +2164,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
     q.messages.push(text);
     // Only notify once (first message), subsequent ones silently queue
     if (isFirst) {
-      await bot.sendMessage(chatId, '📝 收到，中断当前任务后一起处理');
+      await bot.sendMessage(chatId, '📝 收到，稍后一起处理');
     }
     // Interrupt the running Claude process
     const proc = activeProcesses.get(chatId);
@@ -1972,16 +2196,8 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
   const quickAgent = routeAgent(text, config);
   if (quickAgent && !quickAgent.rest) {
     const { key, proj } = quickAgent;
-    const projCwd = expandPath(proj.cwd).replace(/^~/, HOME);
-    const st = loadState();
-    const recentInDir = listRecentSessions(1, projCwd);
-    if (recentInDir.length > 0 && recentInDir[0].sessionId) {
-      st.sessions[chatId] = { id: recentInDir[0].sessionId, cwd: projCwd, started: true };
-    } else {
-      const newSess = createSession(chatId, projCwd, proj.name || key);
-      st.sessions[chatId] = { id: newSess.id, cwd: projCwd, started: false };
-    }
-    saveState(st);
+    const projCwd = normalizeCwd(proj.cwd);
+    attachOrCreateSession(chatId, projCwd, proj.name || key);
     log('INFO', `Agent switch via nickname: ${key} (${projCwd})`);
     await bot.sendMessage(chatId, `${proj.icon || '🤖'} ${proj.name || key} 在线`);
     return;
@@ -2364,6 +2580,9 @@ const CONTENT_EXTENSIONS = new Set([
 // Active Claude processes per chat (for /stop)
 const activeProcesses = new Map(); // chatId -> { child, aborted }
 
+// Pending /bind flows: waiting for user to pick a directory
+const pendingBinds = new Map(); // chatId -> agentName
+
 // Message queue for messages received while a task is running
 const messageQueue = new Map(); // chatId -> { messages: string[], notified: false }
 
@@ -2482,7 +2701,7 @@ function spawnClaudeStreaming(args, input, cwd, onStatus, timeoutMs = 600000, ch
     let killed = false;
     let finalResult = '';
     let lastStatusTime = 0;
-    const STATUS_THROTTLE = 3000; // Min 3s between status updates
+    const STATUS_THROTTLE = STATUS_THROTTLE_MS;
     const writtenFiles = []; // Track files created/modified by Write tool
 
     const timer = setTimeout(() => {
@@ -2641,7 +2860,6 @@ function spawnClaudeStreaming(args, input, cwd, onStatus, timeoutMs = 600000, ch
 }
 
 // Lazy distill: run distill.js in background on first message, then every 4 hours
-let _lastDistillTime = 0;
 // Track outbound message_id → session for reply-based session restoration.
 // Keeps last 200 entries to avoid unbounded growth.
 function trackMsgSession(messageId, session) {
@@ -2658,14 +2876,17 @@ function trackMsgSession(messageId, session) {
 
 function lazyDistill() {
   const now = Date.now();
-  if (now - _lastDistillTime < 4 * 60 * 60 * 1000) return; // 4h cooldown
+  const st = loadState();
+  const lastDistillTime = st.last_distill_time || 0;
+  if (now - lastDistillTime < 4 * 60 * 60 * 1000) return; // 4h cooldown
   const distillPath = path.join(HOME, '.metame', 'distill.js');
   const signalsPath = path.join(HOME, '.metame', 'raw_signals.jsonl');
   if (!fs.existsSync(distillPath)) return;
   if (!fs.existsSync(signalsPath)) return;
   const content = fs.readFileSync(signalsPath, 'utf8').trim();
   if (!content) return;
-  _lastDistillTime = now;
+  st.last_distill_time = now;
+  saveState(st);
   const lines = content.split('\n').filter(l => l.trim()).length;
   log('INFO', `Distilling ${lines} signal(s) in background...`);
   const bg = spawn('node', [distillPath], { detached: true, stdio: 'ignore' });
@@ -2697,16 +2918,8 @@ async function askClaude(bot, chatId, prompt, config) {
   const agentMatch = routeAgent(prompt, config);
   if (agentMatch) {
     const { key, proj, rest } = agentMatch;
-    const projCwd = expandPath(proj.cwd).replace(/^~/, HOME);
-    const st = loadState();
-    const recentInDir = listRecentSessions(1, projCwd);
-    if (recentInDir.length > 0 && recentInDir[0].sessionId) {
-      st.sessions[chatId] = { id: recentInDir[0].sessionId, cwd: projCwd, started: true };
-    } else {
-      const newSess = createSession(chatId, projCwd, proj.name || key);
-      st.sessions[chatId] = { id: newSess.id, cwd: projCwd, started: false };
-    }
-    saveState(st);
+    const projCwd = normalizeCwd(proj.cwd);
+    attachOrCreateSession(chatId, projCwd, proj.name || key);
     log('INFO', `Agent switch via nickname: ${key} (${projCwd})`);
     if (!rest) {
       // Pure nickname call — confirm switch and stop
@@ -2770,7 +2983,11 @@ async function askClaude(bot, chatId, prompt, config) {
   const daemonCfg = loadConfig().daemon || {};
   const model = daemonCfg.model || 'opus';
   args.push('--model', model);
-  if (daemonCfg.dangerously_skip_permissions) {
+  if (readOnly) {
+    // Read-only mode for non-operator users: query/chat only, no write/edit/execute
+    const READ_ONLY_TOOLS = ['Read', 'Glob', 'Grep', 'WebSearch', 'WebFetch', 'Task'];
+    for (const tool of READ_ONLY_TOOLS) args.push('--allowedTools', tool);
+  } else if (daemonCfg.dangerously_skip_permissions) {
     args.push('--dangerously-skip-permissions');
   } else {
     const sessionAllowed = daemonCfg.session_allowed_tools || [];
@@ -2801,14 +3018,22 @@ async function askClaude(bot, chatId, prompt, config) {
   gitCheckpoint(session.cwd);
 
   // Use streaming mode to show progress
-  // Telegram: edit status msg in-place; Feishu/others: send new messages
+  // Telegram: edit status msg in-place; Feishu: edit or fallback to new messages
+  let editFailed = false;
+  let lastFallbackStatus = 0;
+  const FALLBACK_THROTTLE = FALLBACK_THROTTLE_MS;
   const onStatus = async (status) => {
     try {
-      if (statusMsgId && bot.editMessage) {
-        await bot.editMessage(chatId, statusMsgId, status);
-      } else {
-        await bot.sendMessage(chatId, status);
+      if (statusMsgId && bot.editMessage && !editFailed) {
+        const ok = await bot.editMessage(chatId, statusMsgId, status);
+        if (ok !== false) return; // edit succeeded (true or undefined for Telegram)
+        editFailed = true; // edit failed, switch to fallback permanently
       }
+      // Fallback: send as new message with extra throttle to avoid spam
+      const now = Date.now();
+      if (now - lastFallbackStatus < FALLBACK_THROTTLE) return;
+      lastFallbackStatus = now;
+      await bot.sendMessage(chatId, status);
     } catch { /* ignore status update failures */ }
   };
 
@@ -2859,32 +3084,32 @@ async function askClaude(bot, chatId, prompt, config) {
     recordTokens(loadState(), estimated);
 
     // Parse [[FILE:...]] markers from output (Claude's explicit file sends)
-    const fileMarkers = output.match(/\[\[FILE:([^\]]+)\]\]/g) || [];
-    const markedFiles = fileMarkers.map(m => m.match(/\[\[FILE:([^\]]+)\]\]/)[1].trim());
-    const cleanOutput = output.replace(/\s*\[\[FILE:[^\]]+\]\]/g, '').trim();
-
-    const replyMsg = await bot.sendMarkdown(chatId, cleanOutput);
-    if (replyMsg && replyMsg.message_id && session) trackMsgSession(replyMsg.message_id, session);
-
-    // Combine: marked files + auto-detected content files from Write operations
-    const allFiles = new Set(markedFiles);
-    if (files && files.length > 0) {
-      for (const f of files) {
-        if (isContentFile(f)) allFiles.add(f);
+    const { markedFiles, cleanOutput } = parseFileMarkers(output);
+
+    // Match current session to a project for colored card display
+    let activeProject = null;
+    if (session && session.cwd && config && config.projects) {
+      const sessionCwd = path.resolve(normalizeCwd(session.cwd));
+      for (const [, proj] of Object.entries(config.projects)) {
+        if (!proj.cwd) continue;
+        const projCwd = path.resolve(normalizeCwd(proj.cwd));
+        if (sessionCwd === projCwd) { activeProject = proj; break; }
       }
     }
 
-    // Send file buttons
-    if (allFiles.size > 0 && bot.sendButtons) {
-      const validFiles = [...allFiles].filter(f => fs.existsSync(f));
-      if (validFiles.length > 0) {
-        const buttons = validFiles.map(filePath => {
-          const shortId = cacheFile(filePath);
-          return [{ text: `📎 ${path.basename(filePath)}`, callback_data: `/file ${shortId}` }];
-        });
-        await bot.sendButtons(chatId, '📂 文件:', buttons);
-      }
+    let replyMsg;
+    if (activeProject && bot.sendCard) {
+      replyMsg = await bot.sendCard(chatId, {
+        title: `${activeProject.icon || '🤖'} ${activeProject.name || ''}`,
+        body: cleanOutput,
+        color: activeProject.color || 'blue',
+      });
+    } else {
+      replyMsg = await bot.sendMarkdown(chatId, cleanOutput);
     }
+    if (replyMsg && replyMsg.message_id && session) trackMsgSession(replyMsg.message_id, session);
+
+    await sendFileButtons(bot, chatId, mergeFileCollections(markedFiles, files));
 
     // Auto-name: if this was the first message and session has no name, generate one
     if (wasNew && !getSessionName(session.id)) {
@@ -2909,28 +3134,9 @@ async function askClaude(bot, chatId, prompt, config) {
       const retry = await spawnClaudeStreaming(retryArgs, prompt, session.cwd, onStatus);
       if (retry.output) {
         markSessionStarted(chatId);
-        // Parse [[FILE:...]] markers
-        const retryFileMarkers = retry.output.match(/\[\[FILE:([^\]]+)\]\]/g) || [];
-        const retryMarkedFiles = retryFileMarkers.map(m => m.match(/\[\[FILE:([^\]]+)\]\]/)[1].trim());
-        const retryCleanOutput = retry.output.replace(/\s*\[\[FILE:[^\]]+\]\]/g, '').trim();
-        await bot.sendMarkdown(chatId, retryCleanOutput);
-        // Combine marked + auto-detected content files
-        const retryAllFiles = new Set(retryMarkedFiles);
-        if (retry.files && retry.files.length > 0) {
-          for (const f of retry.files) {
-            if (isContentFile(f)) retryAllFiles.add(f);
-          }
-        }
-        if (retryAllFiles.size > 0 && bot.sendButtons) {
-          const validFiles = [...retryAllFiles].filter(f => fs.existsSync(f));
-          if (validFiles.length > 0) {
-            const buttons = validFiles.map(filePath => {
-              const shortId = cacheFile(filePath);
-              return [{ text: `📎 ${path.basename(filePath)}`, callback_data: `/file ${shortId}` }];
-            });
-            await bot.sendButtons(chatId, '📂 文件:', buttons);
-          }
-        }
+        const { markedFiles: retryMarked, cleanOutput: retryClean } = parseFileMarkers(retry.output);
+        await bot.sendMarkdown(chatId, retryClean);
+        await sendFileButtons(bot, chatId, mergeFileCollections(retryMarked, retry.files));
       } else {
         log('ERROR', `askClaude retry failed: ${(retry.error || '').slice(0, 200)}`);
         try { await bot.sendMessage(chatId, `Error: ${(retry.error || '').slice(0, 200)}`); } catch { /* */ }
@@ -2975,16 +3181,34 @@ async function startFeishuBridge(config, executeTaskByName) {
 
   const { createBot } = require(path.join(__dirname, 'feishu-adapter.js'));
   const bot = createBot(config.feishu);
-  const allowedIds = config.feishu.allowed_chat_ids || [];
-
   try {
-    const receiver = await bot.startReceiving(async (chatId, text, event, fileInfo) => {
-      // Security: check whitelist (empty = deny all)
-      if (!allowedIds.includes(chatId)) {
+    const receiver = await bot.startReceiving(async (chatId, text, event, fileInfo, senderId) => {
+      // Security: check whitelist (empty = deny all) — read live config to support hot-reload
+      // Exception: /bind is allowed from any chat so users can self-register new groups
+      const liveCfg = loadConfig();
+      const allowedIds = (liveCfg.feishu && liveCfg.feishu.allowed_chat_ids) || [];
+      const isBindCmd = text && text.trim().startsWith('/bind');
+      if (!allowedIds.includes(chatId) && !isBindCmd) {
         log('WARN', `Feishu: rejected message from ${chatId}`);
         return;
       }
 
+      // Operator check: if operator_ids configured, non-operators get read-only chat mode
+      const operatorIds = (liveCfg.feishu && liveCfg.feishu.operator_ids) || [];
+      if (operatorIds.length > 0 && senderId && !operatorIds.includes(senderId) && !isBindCmd) {
+        log('INFO', `Feishu: read-only message from non-operator ${senderId} in ${chatId}: ${(text || '').slice(0, 50)}`);
+        // Block slash commands for non-operators
+        if (text && text.startsWith('/')) {
+          await bot.sendMessage(chatId, '⚠️ 该操作需要授权，请联系管理员。');
+          return;
+        }
+        // Allow read-only chat (query/answer only, no write/edit/execute)
+        if (text) {
+          await handleCommand(bot, chatId, text, config, executeTaskByName, senderId, true);
+        }
+        return;
+      }
+
       // Handle file message
       if (fileInfo && fileInfo.fileKey) {
         log('INFO', `Feishu file from ${chatId}: ${fileInfo.fileName} (key: ${fileInfo.fileKey}, msgId: ${fileInfo.messageId}, type: ${fileInfo.msgType})`);
@@ -3027,7 +3251,7 @@ async function startFeishuBridge(config, executeTaskByName) {
             log('INFO', `Session restored via reply: ${mapped.id.slice(0, 8)} (${path.basename(mapped.cwd)})`);
           }
         }
-        await handleCommand(bot, chatId, text, config, executeTaskByName);
+        await handleCommand(bot, chatId, text, config, executeTaskByName, senderId);
       }
     });
 

package/scripts/distill.js

@@ -159,6 +159,7 @@ RULES:
 5. Episodic exceptions: context.anti_patterns (max 5, cross-project lessons only), context.milestones (max 3).
 6. Strong directives (以后一律/always/never/from now on) → _confidence: high. Otherwise: normal.
 7. Add _confidence and _source blocks mapping field keys to confidence level and triggering quote.
+8. NEVER extract agent identity or role definitions. Messages like "你是贾维斯/你的角色是.../you are Jarvis" define the AGENT, not the USER. The profile is about the USER's cognition only.
 
 BIAS PREVENTION:
 - Single observation = STATE, not TRAIT. T3 cognition needs 3+ observations.

package/scripts/feishu-adapter.js

@@ -51,13 +51,22 @@ function createBot(config) {
       return msgId ? { message_id: msgId } : null;
     },
 
+    _editBroken: false, // Set to true if patch API consistently fails
     async editMessage(chatId, messageId, text) {
+      if (this._editBroken) return false;
       try {
         await client.im.message.patch({
           path: { message_id: messageId },
           data: { content: JSON.stringify({ text }) },
         });
-      } catch { /* non-fatal */ }
+        return true;
+      } catch (e) {
+        const code = e?.code || e?.response?.data?.code;
+        if (code === 230001 || code === 230002 || /permission|forbidden/i.test(String(e))) {
+          this._editBroken = true;
+        }
+        return false;
+      }
     },
 
     /**
@@ -69,13 +78,12 @@ function createBot(config) {
         .replace(/^(#{1,3})\s+(.+)$/gm, '**$2**')   // headers → bold
         .replace(/^---+$/gm, '─────────────────────');  // hr → unicode line
 
-      // Split into chunks if too long (lark_md element limit ~4000 chars)
+      // Split into chunks if too long (element limit ~4000 chars)
       const MAX_CHUNK = 3800;
       const chunks = [];
       if (content.length <= MAX_CHUNK) {
         chunks.push(content);
       } else {
-        // Split on double newlines to avoid breaking mid-paragraph
         const paragraphs = content.split(/\n\n/);
         let buf = '';
         for (const p of paragraphs) {
@@ -89,14 +97,16 @@ function createBot(config) {
         if (buf) chunks.push(buf);
       }
 
+      // V2 schema: markdown element with normal text size
       const elements = chunks.map(c => ({
-        tag: 'div',
-        text: { tag: 'lark_md', content: c },
+        tag: 'markdown',
+        content: c,
+        text_size: 'x-large',
       }));
 
       const card = {
-        config: { wide_screen_mode: true },
-        elements,
+        schema: '2.0',
+        body: { elements },
       };
 
       const res = await client.im.message.create({
@@ -119,11 +129,56 @@ function createBot(config) {
      * @param {string} color - header color: blue|orange|green|red|grey|purple|turquoise
      */
     async sendCard(chatId, { title, body, color = 'blue' }) {
-      const elements = body ? [{ tag: 'div', text: { tag: 'lark_md', content: body } }] : [];
+      // Use card schema V2 for better text sizing
+      if (!body) {
+        const card = {
+          schema: '2.0',
+          header: { title: { tag: 'plain_text', content: title }, template: color },
+          body: { elements: [] },
+        };
+        const res = await client.im.message.create({
+          params: { receive_id_type: 'chat_id' },
+          data: { receive_id: chatId, msg_type: 'interactive', content: JSON.stringify(card) },
+        });
+        const msgId = res?.data?.message_id;
+        return msgId ? { message_id: msgId } : null;
+      }
+
+      // Convert standard markdown → lark_md
+      let content = body
+        .replace(/^(#{1,3})\s+(.+)$/gm, '**$2**')
+        .replace(/^---+$/gm, '─────────────────────');
+
+      // Split into chunks (lark_md element limit ~4000 chars)
+      const MAX_CHUNK = 3800;
+      const chunks = [];
+      if (content.length <= MAX_CHUNK) {
+        chunks.push(content);
+      } else {
+        const paragraphs = content.split(/\n\n/);
+        let buf = '';
+        for (const p of paragraphs) {
+          if (buf.length + p.length + 2 > MAX_CHUNK && buf) {
+            chunks.push(buf);
+            buf = p;
+          } else {
+            buf = buf ? buf + '\n\n' + p : p;
+          }
+        }
+        if (buf) chunks.push(buf);
+      }
+
+      // V2: use markdown element with text_size for readable font
+      const elements = chunks.map(c => ({
+        tag: 'markdown',
+        content: c,
+        text_size: 'x-large',
+      }));
+
       const card = {
-        config: { wide_screen_mode: true },
+        schema: '2.0',
         header: { title: { tag: 'plain_text', content: title }, template: color },
-        elements,
+        body: { elements },
       };
       const res = await client.im.message.create({
         params: { receive_id_type: 'chat_id' },
@@ -133,6 +188,15 @@ function createBot(config) {
       return msgId ? { message_id: msgId } : null;
     },
 
+    /**
+     * Delete a message by ID
+     */
+    async deleteMessage(chatId, messageId) {
+      try {
+        await client.im.message.delete({ path: { message_id: messageId } });
+      } catch { /* non-fatal — message may already be deleted or expired */ }
+    },
+
     /**
      * Typing indicator (Feishu has no such API — no-op)
      */
@@ -342,6 +406,7 @@ function createBot(config) {
               if (isDuplicate(msg.message_id)) return;
 
               const chatId = msg.chat_id;
+              const senderId = data.sender && data.sender.sender_id && data.sender.sender_id.open_id || null;
               let text = '';
               let fileInfo = null;
 
@@ -370,7 +435,7 @@ function createBot(config) {
 
               if (text || fileInfo) {
                 // Fire-and-forget: don't block the event loop (SDK needs fast ack)
-                Promise.resolve().then(() => onMessage(chatId, text, data, fileInfo)).catch(() => {});
+                Promise.resolve().then(() => onMessage(chatId, text, data, fileInfo, senderId)).catch(() => {});
               }
             } catch (e) {
               // Non-fatal

package/scripts/schema.js

@@ -16,8 +16,7 @@
  */
 
 const SCHEMA = {
-  // === T1: Identity ===
-  'identity.nickname':        { tier: 'T1', type: 'string', locked: true },
+  // === T1: Identity (USER's identity, not agent's) ===
   'identity.role':            { tier: 'T1', type: 'string', locked: false },
   'identity.locale':          { tier: 'T1', type: 'string', locked: true },
 

package/scripts/signal-capture.js

@@ -65,6 +65,11 @@ process.stdin.on('end', () => {
       process.exit(0);
     }
 
+    // Skip agent identity definitions (these belong in project CLAUDE.md, not user profile)
+    if (/^(你是|你叫|你的(角色|身份|职责|任务)|你负责|你现在是|from now on you are|you are now|your role is)/i.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);