metame-cli 1.3.6 → 1.3.8

package/README.md

@@ -19,7 +19,7 @@ It is not a memory system; it is a  **Cognitive Mirror** .
 ## ✨ Key Features
 
 * **🧠 Global Brain (`~/.claude_profile.yaml`):** A single, portable source of truth — your identity, cognitive traits, and preferences travel with you across every project.
-* **🧬 Cognitive Evolution Engine:** MetaMe learns how you think through three channels: (1) **Passive** — silently captures your messages and distills cognitive traits via Haiku on next launch; (2) **Manual** — `!metame evolve` for explicit teaching; (3) **Confidence gates** — strong directives ("always"/"以后一律") write immediately, normal observations need 3+ consistent sightings before promotion. Schema-enforced (41 fields, 5 tiers, 800 token budget) to prevent bloat.
+* **🧬 Cognitive Evolution Engine:** MetaMe learns how you think through three channels: (1) **Passive** — silently captures your messages and distills cognitive traits via Haiku on next launch; (2) **Manual** — `!metame evolve` for explicit teaching; (3) **Confidence gates** — strong directives ("always"/"from now on") write immediately, normal observations need 3+ consistent sightings before promotion. Schema-enforced (41 fields, 5 tiers, 800 token budget) to prevent bloat.
 * **🛡️ Auto-Lock:** Mark any value with `# [LOCKED]` — treated as a constitution, never auto-modified.
 * **🪞 Metacognition Layer (v1.3):** MetaMe now observes *how* you think, not just *what* you say. Behavioral pattern detection runs inside the existing Haiku distill call (zero extra cost). It tracks decision patterns, cognitive load, comfort zones, and avoidance topics across sessions. When persistent patterns emerge, MetaMe injects a one-line mirror observation — e.g., *"You tend to avoid testing until forced"* — with a 14-day cooldown per pattern. Conditional reflection prompts appear only when triggered (every 7th distill or 3x consecutive comfort zone). All injection logic runs in Node.js; Claude receives only pre-decided directives, never rules to self-evaluate.
 * **📱 Remote Claude Code (v1.3):** Full Claude Code from your phone via Telegram or Feishu (Lark). Stateful sessions with `--resume` — same conversation history, tool use, and file editing as your terminal. Interactive buttons for project/session picking, directory browser, and macOS launchd auto-start.
@@ -93,7 +93,7 @@ metame interview
 
 MetaMe learns who you are through two paths:
 
-**Automatic (zero effort):** A global hook captures your messages. On next launch, Haiku distills cognitive traits in the background. Strong directives ("always"/"以后一律") write immediately; normal observations need 3+ consistent sightings. All writes are schema-validated (41 fields, 800 token budget). You'll see:
+**Automatic (zero effort):** A global hook captures your messages. On next launch, Haiku distills cognitive traits in the background. Strong directives ("always"/"from now on") write immediately; normal observations need 3+ consistent sightings. All writes are schema-validated (41 fields, 800 token budget). You'll see:
 
 ```
 🧠 MetaMe: Distilling 7 moments in background...
@@ -161,9 +161,9 @@ metame daemon install-launchd         # macOS auto-start (RunAtLoad + KeepAlive)
 
 | Command | Description |
 |---------|-------------|
-| `/last` | **Quick resume** — 优先当前目录最近 session，否则全局最近 |
+| `/last` | **Quick resume** — prefers current directory's recent session, falls back to global recent |
 | `/new` | Start new session — pick project directory from button list |
-| `/new <name>` | Start new session with a name (e.g., `/new API重构`) |
+| `/new <name>` | Start new session with a name (e.g., `/new API Refactor`) |
 | `/resume` | Resume a session — clickable list, shows session names + real-time timestamps |
 | `/resume <name>` | Resume by name (supports partial match, cross-project) |
 | `/name <name>` | Name the current session (syncs with computer's `/rename`) |
@@ -182,6 +182,27 @@ Each chat gets a persistent session via `claude -p --resume <session-id>`. This
 
 **Parallel request handling:** The daemon uses async spawning, so multiple users or overlapping requests don't block each other. Each Claude call runs in a non-blocking subprocess.
 
+**Streaming status (v1.3.7):** See Claude's work progress in real-time on your phone:
+
+```
+📖 Read: 「config.yaml」
+✏️ Edit: 「daemon.js」
+💻 Bash: 「git status」
+```
+
+**File sending (v1.3.7):** Ask Claude to send any file to your phone:
+
+```
+You: Send me report.md
+Claude: Here you go!
+        [📎 report.md]  ← tap to download
+```
+
+Works for documents, audio, images, etc. Click button to download. Links valid for 30 minutes.
+
+- **Telegram:** Works out of the box
+- **Feishu:** Requires `im:resource` permission in app settings
+
 **Other commands:**
 
 | Command | Description |

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.3.6",
+    "version": "1.3.8",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {
@@ -12,7 +12,7 @@
     ],
     "scripts": {
         "start": "node index.js",
-        "sync:plugin": "cp scripts/schema.js scripts/pending-traits.js scripts/signal-capture.js scripts/daemon.js scripts/telegram-adapter.js scripts/feishu-adapter.js scripts/daemon-default.yaml plugin/scripts/ && echo '✅ Plugin scripts synced'",
+        "sync:plugin": "cp scripts/schema.js scripts/pending-traits.js scripts/signal-capture.js scripts/distill.js scripts/daemon.js scripts/telegram-adapter.js scripts/feishu-adapter.js scripts/daemon-default.yaml plugin/scripts/ && echo '✅ Plugin scripts synced'",
         "precommit": "npm run sync:plugin"
     },
     "keywords": [

package/scripts/daemon.js

@@ -492,6 +492,36 @@ async function startTelegramBridge(config, executeTaskByName) {
             continue;
           }
 
+          // File/document message → download and pass to Claude
+          if (msg.document || msg.photo) {
+            const fileId = msg.document ? msg.document.file_id : msg.photo[msg.photo.length - 1].file_id;
+            const fileName = msg.document ? msg.document.file_name : `photo_${Date.now()}.jpg`;
+            const caption = msg.caption || '';
+
+            // Save to project's upload/ folder
+            const session = getSession(chatId);
+            const cwd = session?.cwd || HOME;
+            const uploadDir = path.join(cwd, 'upload');
+            if (!fs.existsSync(uploadDir)) fs.mkdirSync(uploadDir, { recursive: true });
+            const destPath = path.join(uploadDir, fileName);
+
+            try {
+              await bot.downloadFile(fileId, destPath);
+              await bot.sendMessage(chatId, `📥 Saved: ${fileName}`);
+
+              // Build prompt - don't ask Claude to read large files automatically
+              const prompt = caption
+                ? `User uploaded a file to the project: ${destPath}\nUser says: "${caption}"`
+                : `User uploaded a file to the project: ${destPath}\nAcknowledge receipt. Only read the file if the user asks you to.`;
+
+              await handleCommand(bot, chatId, prompt, config, executeTaskByName);
+            } catch (err) {
+              log('ERROR', `File download failed: ${err.message}`);
+              await bot.sendMessage(chatId, `❌ Download failed: ${err.message}`);
+            }
+            continue;
+          }
+
           // Text message (commands or natural language)
           if (msg.text) {
             await handleCommand(bot, chatId, msg.text.trim(), config, executeTaskByName);
@@ -655,6 +685,36 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
     return;
   }
 
+  // /file <shortId> — send cached file (from button callback)
+  if (text.startsWith('/file ')) {
+    const shortId = text.slice(6).trim();
+    const filePath = getCachedFile(shortId);
+    if (!filePath) {
+      await bot.sendMessage(chatId, '⏰ 文件链接已过期，请重新生成');
+      return;
+    }
+    if (!fs.existsSync(filePath)) {
+      await bot.sendMessage(chatId, '❌ 文件不存在');
+      return;
+    }
+    if (bot.sendFile) {
+      try {
+        // Insert zero-width space before extension to prevent link parsing
+        const basename = path.basename(filePath);
+        const dotIdx = basename.lastIndexOf('.');
+        const safeBasename = dotIdx > 0 ? basename.slice(0, dotIdx) + '\u200B' + basename.slice(dotIdx) : basename;
+        await bot.sendMessage(chatId, `⏳ 正在发送「${safeBasename}」...`);
+        await bot.sendFile(chatId, filePath);
+      } catch (e) {
+        log('ERROR', `File send failed: ${e.message}`);
+        await bot.sendMessage(chatId, `❌ 发送失败: ${e.message.slice(0, 100)}`);
+      }
+    } else {
+      await bot.sendMessage(chatId, '❌ 当前平台不支持文件发送');
+    }
+    return;
+  }
+
   // /last — smart resume: prefer current cwd, then most recent globally
   if (text === '/last') {
     const curSession = getSession(chatId);
@@ -772,11 +832,26 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
       await sendDirPicker(bot, chatId, 'cd', 'Switch workdir:');
       return;
     }
-    // /cd last — jump to the most recent session's directory globally
+    // /cd last — sync to computer: switch to most recent session AND its directory
     if (newCwd === 'last') {
-      const recent = listRecentSessions(1);
-      if (recent.length > 0 && recent[0].projectPath) {
-        newCwd = recent[0].projectPath;
+      const currentSession = getSession(chatId);
+      const excludeId = currentSession?.id;
+      const recent = listRecentSessions(10);
+      const filtered = excludeId ? recent.filter(s => s.sessionId !== excludeId) : recent;
+      if (filtered.length > 0 && filtered[0].projectPath) {
+        const target = filtered[0];
+        // Switch to that session (like /resume) AND its directory
+        const state2 = loadState();
+        state2.sessions[chatId] = {
+          id: target.sessionId,
+          cwd: target.projectPath,
+          started: true,
+        };
+        saveState(state2);
+        const name = target.customTitle || target.summary || '';
+        const label = name ? name.slice(0, 40) : target.sessionId.slice(0, 8);
+        await bot.sendMessage(chatId, `🔄 Synced to: ${label}\n📁 ${path.basename(target.projectPath)}`);
+        return;
       } else {
         await bot.sendMessage(chatId, 'No recent session found.');
         return;
@@ -787,13 +862,27 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
       return;
     }
     const state2 = loadState();
-    if (!state2.sessions[chatId]) {
+    // Try to find existing session in this directory
+    const recentInDir = listRecentSessions(1, newCwd);
+    if (recentInDir.length > 0 && recentInDir[0].sessionId) {
+      // Attach to existing session in this directory
+      const target = recentInDir[0];
+      state2.sessions[chatId] = {
+        id: target.sessionId,
+        cwd: newCwd,
+        started: true,
+      };
+      saveState(state2);
+      const label = target.customTitle || target.summary?.slice(0, 30) || target.sessionId.slice(0, 8);
+      await bot.sendMessage(chatId, `📁 ${path.basename(newCwd)}\n🔄 Attached: ${label}`);
+    } else if (!state2.sessions[chatId]) {
       createSession(chatId, newCwd);
+      await bot.sendMessage(chatId, `📁 ${path.basename(newCwd)} (new session)`);
     } else {
       state2.sessions[chatId].cwd = newCwd;
       saveState(state2);
+      await bot.sendMessage(chatId, `📁 ${path.basename(newCwd)}`);
     }
-    await bot.sendMessage(chatId, `Workdir: ${newCwd}`);
     return;
   }
 
@@ -904,17 +993,22 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
 
   if (text.startsWith('/')) {
     await bot.sendMessage(chatId, [
-      'Commands:',
-      '/last — ⚡ 一键继续最近的 session',
-      '/new [path] [name] — new session',
-      '/resume [name] — 选择/搜索 session',
-      '/continue — resume last in current dir',
-      '/name <name> — name current session',
-      '/cd <path|last> — change workdir (last=最近目录)',
-      '/session — current session info',
-      '/status /tasks /budget /reload',
+      '📱 手机端 Claude Code',
+      '',
+      '⚡ 快速同步电脑工作:',
+      '/last — 继续电脑上最近的对话',
+      '/cd last — 切到电脑最近的项目目录',
       '',
-      'Or just type naturally.',
+      '📂 Session 管理:',
+      '/new [path] [name] — 新建会话',
+      '/resume [name] — 选择/恢复会话',
+      '/name <name> — 命名当前会话',
+      '/cd <path> — 切换工作目录',
+      '/session — 查看当前会话',
+      '',
+      '⚙️ /status /tasks /budget /reload',
+      '',
+      '直接打字即可对话 💬',
     ].join('\n'));
     return;
   }
@@ -1265,6 +1359,205 @@ function spawnClaudeAsync(args, input, cwd, timeoutMs = 300000) {
   });
 }
 
+/**
+ * Tool name to emoji mapping for status display
+ */
+const TOOL_EMOJI = {
+  Read: '📖',
+  Edit: '✏️',
+  Write: '📝',
+  Bash: '💻',
+  Glob: '🔍',
+  Grep: '🔎',
+  WebFetch: '🌐',
+  WebSearch: '🔍',
+  Task: '🤖',
+  default: '🔧',
+};
+
+// Content file extensions (user-facing files, not code/config)
+const CONTENT_EXTENSIONS = new Set([
+  '.md', '.txt', '.rtf',                          // Text
+  '.doc', '.docx', '.pdf', '.odt',                // Documents
+  '.wav', '.mp3', '.m4a', '.ogg', '.flac',        // Audio
+  '.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', // Images
+  '.mp4', '.mov', '.avi', '.webm',                // Video
+  '.csv', '.xlsx', '.xls',                        // Data
+  '.html', '.htm',                                // Web content
+]);
+
+// File cache for button callbacks (shortId -> fullPath)
+const fileCache = new Map();
+const FILE_CACHE_TTL = 1800000; // 30 minutes
+
+function cacheFile(filePath) {
+  const shortId = Math.random().toString(36).slice(2, 10);
+  fileCache.set(shortId, { path: filePath, expires: Date.now() + FILE_CACHE_TTL });
+  return shortId;
+}
+
+function getCachedFile(shortId) {
+  const entry = fileCache.get(shortId);
+  if (!entry) return null;
+  if (Date.now() > entry.expires) {
+    fileCache.delete(shortId);
+    return null;
+  }
+  return entry.path;
+}
+
+function isContentFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return CONTENT_EXTENSIONS.has(ext);
+}
+
+/**
+ * Spawn claude with streaming output (stream-json mode).
+ * Calls onStatus callback when tool usage is detected.
+ * Returns { output, error } after process exits.
+ */
+function spawnClaudeStreaming(args, input, cwd, onStatus, timeoutMs = 600000) {
+  return new Promise((resolve) => {
+    // Add stream-json output format (requires --verbose)
+    const streamArgs = [...args, '--output-format', 'stream-json', '--verbose'];
+
+    const child = spawn('claude', streamArgs, {
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env },
+    });
+
+    let buffer = '';
+    let stderr = '';
+    let killed = false;
+    let finalResult = '';
+    let lastStatusTime = 0;
+    const STATUS_THROTTLE = 3000; // Min 3s between status updates
+    const writtenFiles = []; // Track files created/modified by Write tool
+
+    const timer = setTimeout(() => {
+      killed = true;
+      child.kill('SIGTERM');
+    }, timeoutMs);
+
+    child.stdout.on('data', (data) => {
+      buffer += data.toString();
+
+      // Process complete JSON lines
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || ''; // Keep incomplete line in buffer
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const event = JSON.parse(line);
+
+          // Extract final result text
+          if (event.type === 'assistant' && event.message?.content) {
+            const textBlocks = event.message.content.filter(b => b.type === 'text');
+            if (textBlocks.length > 0) {
+              finalResult = textBlocks.map(b => b.text).join('\n');
+            }
+          }
+
+          // Detect tool usage and send status
+          if (event.type === 'assistant' && event.message?.content) {
+            for (const block of event.message.content) {
+              if (block.type === 'tool_use') {
+                const toolName = block.name || 'Tool';
+
+                // Track files written by Write tool
+                if (toolName === 'Write' && block.input?.file_path) {
+                  const filePath = block.input.file_path;
+                  if (!writtenFiles.includes(filePath)) {
+                    writtenFiles.push(filePath);
+                  }
+                }
+
+                const now = Date.now();
+                if (now - lastStatusTime >= STATUS_THROTTLE) {
+                  lastStatusTime = now;
+                  const emoji = TOOL_EMOJI[toolName] || TOOL_EMOJI.default;
+
+                  // Extract brief context from tool input
+                  let context = '';
+                  if (block.input) {
+                    if (block.input.file_path) {
+                      // Insert zero-width space before extension to prevent link parsing
+                      const basename = path.basename(block.input.file_path);
+                      const dotIdx = basename.lastIndexOf('.');
+                      context = dotIdx > 0 ? basename.slice(0, dotIdx) + '\u200B' + basename.slice(dotIdx) : basename;
+                    } else if (block.input.command) {
+                      context = block.input.command.slice(0, 30);
+                      if (block.input.command.length > 30) context += '...';
+                    } else if (block.input.pattern) {
+                      context = block.input.pattern.slice(0, 20);
+                    } else if (block.input.query) {
+                      context = block.input.query.slice(0, 25);
+                    } else if (block.input.url) {
+                      try {
+                        context = new URL(block.input.url).hostname;
+                      } catch { context = 'web'; }
+                    }
+                  }
+
+                  const status = context
+                    ? `${emoji} ${toolName}: 「${context}」`
+                    : `${emoji} ${toolName}...`;
+
+                  if (onStatus) {
+                    onStatus(status).catch(() => {});
+                  }
+                }
+              }
+            }
+          }
+
+          // Also check for result message type
+          if (event.type === 'result' && event.result) {
+            finalResult = event.result;
+          }
+        } catch {
+          // Not valid JSON, ignore
+        }
+      }
+    });
+
+    child.stderr.on('data', (data) => { stderr += data.toString(); });
+
+    child.on('close', (code) => {
+      clearTimeout(timer);
+
+      // Process any remaining buffer
+      if (buffer.trim()) {
+        try {
+          const event = JSON.parse(buffer);
+          if (event.type === 'result' && event.result) {
+            finalResult = event.result;
+          }
+        } catch { /* ignore */ }
+      }
+
+      if (killed) {
+        resolve({ output: finalResult || null, error: 'Timeout: Claude took too long', files: writtenFiles });
+      } else if (code !== 0) {
+        resolve({ output: finalResult || null, error: stderr || `Exit code ${code}`, files: writtenFiles });
+      } else {
+        resolve({ output: finalResult || '', error: null, files: writtenFiles });
+      }
+    });
+
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      resolve({ output: null, error: err.message, files: [] });
+    });
+
+    // Write input and close stdin
+    child.stdin.write(input);
+    child.stdin.end();
+  });
+}
+
 /**
  * Shared ask logic — full Claude Code session (stateful, with tools)
  * Now uses spawn (async) instead of execSync to allow parallel requests.
@@ -1284,7 +1577,22 @@ async function askClaude(bot, chatId, prompt) {
 
   let session = getSession(chatId);
   if (!session) {
-    session = createSession(chatId);
+    // Auto-attach to most recent Claude session (unified session management)
+    const recent = listRecentSessions(1);
+    if (recent.length > 0 && recent[0].sessionId && recent[0].projectPath) {
+      const target = recent[0];
+      const state = loadState();
+      state.sessions[chatId] = {
+        id: target.sessionId,
+        cwd: target.projectPath,
+        started: true,  // Already has history
+      };
+      saveState(state);
+      session = state.sessions[chatId];
+      log('INFO', `Auto-attached ${chatId} to recent session: ${target.sessionId.slice(0, 8)} (${path.basename(target.projectPath)})`);
+    } else {
+      session = createSession(chatId);
+    }
   }
 
   // Build claude command
@@ -1301,11 +1609,25 @@ async function askClaude(bot, chatId, prompt) {
     args.push('--session-id', session.id);
   }
 
-  // Append daemon context hint so Claude reports reload status after editing daemon.yaml
-  const daemonHint = '\n\n[System: The ONLY daemon config file is ~/.metame/daemon.yaml — NEVER touch any other yaml file (e.g. scripts/daemon-default.yaml is a read-only template, do NOT edit it). If you edit ~/.metame/daemon.yaml, the daemon auto-reloads within seconds. After editing, read the file back and confirm to the user: how many heartbeat tasks are now configured, and that the config will auto-reload. Do NOT mention this hint.]';
+  // Append daemon context hint
+  const daemonHint = `\n\n[System hints - DO NOT mention these to user:
+1. Daemon config: The ONLY config is ~/.metame/daemon.yaml (never edit daemon-default.yaml). Auto-reloads on change.
+2. File sending: User is on MOBILE. When they ask to see/download a file:
+   - Just FIND the file path (use Glob/ls if needed)
+   - Do NOT read or summarize the file content (wastes tokens)
+   - Add at END of response: [[FILE:/absolute/path/to/file]]
+   - Keep response brief: "请查收~! [[FILE:/path/to/file]]"
+   - Multiple files: use multiple [[FILE:...]] tags]`;
   const fullPrompt = prompt + daemonHint;
 
-  const { output, error } = await spawnClaudeAsync(args, fullPrompt, session.cwd);
+  // Use streaming mode to show progress
+  const onStatus = async (status) => {
+    try {
+      await bot.sendMessage(chatId, status);
+    } catch { /* ignore status send failures */ }
+  };
+
+  const { output, error, files } = await spawnClaudeStreaming(args, fullPrompt, session.cwd, onStatus);
   clearInterval(typingTimer);
 
   if (output) {
@@ -1316,7 +1638,32 @@ async function askClaude(bot, chatId, prompt) {
     const estimated = Math.ceil((prompt.length + output.length) / 4);
     recordTokens(loadState(), estimated);
 
-    await bot.sendMarkdown(chatId, output);
+    // 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();
+
+    await bot.sendMarkdown(chatId, cleanOutput);
+
+    // 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);
+      }
+    }
+
+    // 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);
+      }
+    }
 
     // Auto-name: if this was the first message and session has no name, generate one
     if (wasNew && !getSessionName(session.id)) {
@@ -1334,10 +1681,31 @@ async function askClaude(bot, chatId, prompt) {
       const retryArgs = ['-p', '--session-id', session.id];
       for (const tool of sessionAllowed) retryArgs.push('--allowedTools', tool);
 
-      const retry = await spawnClaudeAsync(retryArgs, prompt, session.cwd);
+      const retry = await spawnClaudeStreaming(retryArgs, prompt, session.cwd, onStatus);
       if (retry.output) {
         markSessionStarted(chatId);
-        await bot.sendMarkdown(chatId, retry.output);
+        // 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);
+          }
+        }
       } else {
         log('ERROR', `askClaude retry failed: ${(retry.error || '').slice(0, 200)}`);
         try { await bot.sendMessage(chatId, `Error: ${(retry.error || '').slice(0, 200)}`); } catch { /* */ }
@@ -1363,15 +1731,45 @@ async function startFeishuBridge(config, executeTaskByName) {
   const allowedIds = config.feishu.allowed_chat_ids || [];
 
   try {
-    const receiver = await bot.startReceiving((chatId, text, event) => {
+    const receiver = await bot.startReceiving(async (chatId, text, event, fileInfo) => {
       // Security: check whitelist (empty = allow all)
       if (allowedIds.length > 0 && !allowedIds.includes(chatId)) {
         log('WARN', `Feishu: rejected message from ${chatId}`);
         return;
       }
 
-      log('INFO', `Feishu message from ${chatId}: ${text.slice(0, 50)}`);
-      handleCommand(bot, chatId, text, config, executeTaskByName);
+      // Handle file message
+      if (fileInfo && fileInfo.fileKey) {
+        log('INFO', `Feishu file from ${chatId}: ${fileInfo.fileName} (key: ${fileInfo.fileKey}, msgId: ${fileInfo.messageId}, type: ${fileInfo.msgType})`);
+        // Save to project's upload/ folder
+        const session = getSession(chatId);
+        const cwd = session?.cwd || HOME;
+        const uploadDir = path.join(cwd, 'upload');
+        if (!fs.existsSync(uploadDir)) fs.mkdirSync(uploadDir, { recursive: true });
+        const destPath = path.join(uploadDir, fileInfo.fileName);
+
+        try {
+          await bot.downloadFile(fileInfo.messageId, fileInfo.fileKey, destPath, fileInfo.msgType);
+          await bot.sendMessage(chatId, `📥 Saved: ${fileInfo.fileName}`);
+
+          // Build prompt - don't ask Claude to read large files automatically
+          const prompt = text
+            ? `User uploaded a file to the project: ${destPath}\nUser says: "${text}"`
+            : `User uploaded a file to the project: ${destPath}\nAcknowledge receipt. Only read the file if the user asks you to.`;
+
+          handleCommand(bot, chatId, prompt, config, executeTaskByName);
+        } catch (err) {
+          log('ERROR', `Feishu file download failed: ${err.message}`);
+          await bot.sendMessage(chatId, `❌ Download failed: ${err.message}`);
+        }
+        return;
+      }
+
+      // Handle text message
+      if (text) {
+        log('INFO', `Feishu message from ${chatId}: ${text.slice(0, 50)}`);
+        handleCommand(bot, chatId, text, config, executeTaskByName);
+      }
     });
 
     log('INFO', 'Feishu bot connected (WebSocket long connection)');

package/scripts/distill.js

@@ -174,7 +174,7 @@ Do NOT repeat existing unchanged values. Only output NEW or CHANGED fields.`;
     let result;
     try {
       result = execSync(
-        `claude -p --model haiku`,
+        `claude -p --model haiku --no-session-persistence`,
         {
           input: distillPrompt,
           encoding: 'utf8',
@@ -673,7 +673,7 @@ If no clear patterns found: respond with exactly NO_PATTERNS`;
 
   try {
     const result = execSync(
-      `claude -p --model haiku`,
+      `claude -p --model haiku --no-session-persistence`,
       {
         input: patternPrompt,
         encoding: 'utf8',

package/scripts/feishu-adapter.js

@@ -6,6 +6,9 @@
 
 'use strict';
 
+const fs = require('fs');
+const path = require('path');
+
 let Lark;
 try {
   Lark = require('@larksuiteoapi/node-sdk');
@@ -108,6 +111,131 @@ function createBot(config) {
       return { app_id, app_name: 'MetaMe' };
     },
 
+    /**
+     * Download a file from Feishu to local disk
+     * @param {string} messageId - Message ID containing the file
+     * @param {string} fileKey - File key from message content
+     * @param {string} destPath - Local destination path
+     * @returns {Promise<string>} The destination path
+     */
+    async downloadFile(messageId, fileKey, destPath, msgType = 'file') {
+      try {
+        let res;
+        if (msgType === 'image') {
+          // Images use im.image.get API
+          res = await client.im.image.get({
+            path: { image_key: fileKey },
+          });
+        } else {
+          // Files and media use im.messageResource.get API
+          res = await client.im.messageResource.get({
+            path: { message_id: messageId, file_key: fileKey },
+            params: { type: 'file' },
+          });
+        }
+
+        // SDK returns writeFile method or getReadableStream
+        if (res && res.writeFile) {
+          await res.writeFile(destPath);
+          return destPath;
+        } else if (res && res.getReadableStream) {
+          const stream = res.getReadableStream();
+          const fileStream = fs.createWriteStream(destPath);
+          return new Promise((resolve, reject) => {
+            stream.pipe(fileStream);
+            fileStream.on('finish', () => {
+              fileStream.close();
+              resolve(destPath);
+            });
+            fileStream.on('error', (err) => {
+              fs.unlink(destPath, () => {});
+              reject(err);
+            });
+          });
+        }
+        throw new Error('No writeFile or stream in response');
+      } catch (err) {
+        const detail = err.message || String(err);
+        throw new Error(detail);
+      }
+    },
+
+    /**
+     * Send a file/document
+     * @param {string} chatId
+     * @param {string} filePath - Local file path
+     * @param {string} [caption] - Optional caption (sent as separate message)
+     */
+    async sendFile(chatId, filePath, caption) {
+      if (!fs.existsSync(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+      }
+      const fileName = path.basename(filePath);
+      const fileSize = fs.statSync(filePath).size;
+
+      // For text files under 4KB, just send as text
+      const ext = path.extname(filePath).toLowerCase();
+      const isText = ['.md', '.txt', '.json', '.yaml', '.yml', '.csv'].includes(ext);
+      if (isText && fileSize < 4096) {
+        const content = fs.readFileSync(filePath, 'utf8');
+        await this.sendMessage(chatId, `📄 ${fileName}:\n\`\`\`\n${content}\n\`\`\``);
+        return;
+      }
+
+      // For larger/binary files, try file upload
+      try {
+        // Use ReadStream as per Feishu SDK docs
+        const fileStream = fs.createReadStream(filePath);
+
+        // 1. Upload file to Feishu
+        const uploadRes = await client.im.file.create({
+          data: {
+            file_type: 'stream',
+            file_name: fileName,
+            file: fileStream,
+          },
+        });
+
+        console.log('[Feishu] Upload response:', JSON.stringify(uploadRes));
+
+        // Response is { code, msg, data: { file_key } }
+        const fileKey = uploadRes?.data?.file_key || uploadRes?.file_key;
+        if (!fileKey) {
+          throw new Error(`No file_key in response: ${JSON.stringify(uploadRes)}`);
+        }
+
+        // 2. Send file message
+        await client.im.message.create({
+          params: { receive_id_type: 'chat_id' },
+          data: {
+            receive_id: chatId,
+            msg_type: 'file',
+            content: JSON.stringify({ file_key: fileKey }),
+          },
+        });
+      } catch (uploadErr) {
+        // Log detailed error
+        const errDetail = uploadErr.response?.data || uploadErr.message || uploadErr;
+        console.error('[Feishu] File upload error:', JSON.stringify(errDetail));
+
+        // Fallback: for text files, send content truncated
+        if (isText) {
+          const content = fs.readFileSync(filePath, 'utf8');
+          const truncated = content.length > 3000 ? content.slice(0, 3000) + '\n...(truncated)' : content;
+          await this.sendMessage(chatId, `📄 ${fileName}:\n\`\`\`\n${truncated}\n\`\`\``);
+        } else {
+          // For binary files, give more helpful error
+          const errMsg = errDetail?.msg || errDetail?.message || '上传失败';
+          throw new Error(`${errMsg} (请检查飞书应用权限: im:resource)`);
+        }
+      }
+
+      // 3. Send caption as separate message if provided
+      if (caption) {
+        await this.sendMessage(chatId, caption);
+      }
+    },
+
     /**
      * Start WebSocket long connection to receive messages
      * @param {function} onMessage - callback(chatId, text, event)
@@ -149,6 +277,7 @@ function createBot(config) {
 
               const chatId = msg.chat_id;
               let text = '';
+              let fileInfo = null;
 
               if (msg.message_type === 'text') {
                 try {
@@ -157,14 +286,25 @@ function createBot(config) {
                 } catch {
                   text = msg.content || '';
                 }
+              } else if (msg.message_type === 'file' || msg.message_type === 'image' || msg.message_type === 'media') {
+                // File, image or media (video) message
+                try {
+                  const content = JSON.parse(msg.content);
+                  fileInfo = {
+                    messageId: msg.message_id,
+                    fileKey: content.file_key || content.image_key,
+                    fileName: content.file_name || content.image_key || `file_${Date.now()}`,
+                    msgType: msg.message_type, // 'file', 'image', or 'media'
+                  };
+                } catch {}
               }
 
               // Strip @mention prefix if present
               text = text.replace(/@_user_\d+\s*/g, '').trim();
 
-              if (text) {
+              if (text || fileInfo) {
                 // Fire-and-forget: don't block the event loop (SDK needs fast ack)
-                Promise.resolve().then(() => onMessage(chatId, text, data)).catch(() => {});
+                Promise.resolve().then(() => onMessage(chatId, text, data, fileInfo)).catch(() => {});
               }
             } catch (e) {
               // Non-fatal

package/scripts/telegram-adapter.js

@@ -7,6 +7,8 @@
 'use strict';
 
 const https = require('https');
+const fs = require('fs');
+const path = require('path');
 
 const API_BASE = 'https://api.telegram.org';
 
@@ -169,6 +171,111 @@ function createBot(token) {
       });
     },
 
+    /**
+     * Download a file from Telegram to local disk
+     * @param {string} fileId - Telegram file_id
+     * @param {string} destPath - Local destination path
+     * @returns {Promise<string>} The destination path
+     */
+    async downloadFile(fileId, destPath) {
+      // 1. Get file path from Telegram
+      const fileInfo = await apiRequest(token, 'getFile', { file_id: fileId });
+      if (!fileInfo.file_path) {
+        throw new Error('Failed to get file path from Telegram');
+      }
+
+      // 2. Download file using stream (zero memory overhead)
+      const fileUrl = `${API_BASE}/file/bot${token}/${fileInfo.file_path}`;
+      return new Promise((resolve, reject) => {
+        const urlObj = new URL(fileUrl);
+        https.get({
+          hostname: urlObj.hostname,
+          path: urlObj.pathname,
+          timeout: 60000,
+        }, (res) => {
+          if (res.statusCode !== 200) {
+            reject(new Error(`Download failed: ${res.statusCode}`));
+            return;
+          }
+          const fileStream = fs.createWriteStream(destPath);
+          res.pipe(fileStream);
+          fileStream.on('finish', () => {
+            fileStream.close();
+            resolve(destPath);
+          });
+          fileStream.on('error', (err) => {
+            fs.unlink(destPath, () => {});
+            reject(err);
+          });
+        }).on('error', reject);
+      });
+    },
+
+    /**
+     * Send a file/document
+     * @param {number|string} chatId - Target chat ID
+     * @param {string} filePath - Local file path
+     * @param {string} [caption] - Optional caption
+     */
+    async sendFile(chatId, filePath, caption) {
+      if (!fs.existsSync(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+      }
+      const fileName = path.basename(filePath);
+      const fileContent = fs.readFileSync(filePath);
+      const boundary = '----MetaMeBoundary' + Date.now();
+
+      // Build multipart form-data
+      let body = '';
+      body += `--${boundary}\r\n`;
+      body += `Content-Disposition: form-data; name="chat_id"\r\n\r\n${chatId}\r\n`;
+      if (caption) {
+        body += `--${boundary}\r\n`;
+        body += `Content-Disposition: form-data; name="caption"\r\n\r\n${caption}\r\n`;
+      }
+      body += `--${boundary}\r\n`;
+      body += `Content-Disposition: form-data; name="document"; filename="${fileName}"\r\n`;
+      body += `Content-Type: application/octet-stream\r\n\r\n`;
+
+      const bodyStart = Buffer.from(body, 'utf8');
+      const bodyEnd = Buffer.from(`\r\n--${boundary}--\r\n`, 'utf8');
+      const fullBody = Buffer.concat([bodyStart, fileContent, bodyEnd]);
+
+      return new Promise((resolve, reject) => {
+        const url = `${API_BASE}/bot${token}/sendDocument`;
+        const urlObj = new URL(url);
+        const options = {
+          hostname: urlObj.hostname,
+          path: urlObj.pathname,
+          method: 'POST',
+          headers: {
+            'Content-Type': `multipart/form-data; boundary=${boundary}`,
+            'Content-Length': fullBody.length,
+          },
+          timeout: 60000,
+        };
+
+        const req = https.request(options, (res) => {
+          let data = '';
+          res.on('data', (chunk) => { data += chunk; });
+          res.on('end', () => {
+            try {
+              const parsed = JSON.parse(data);
+              if (parsed.ok) resolve(parsed.result);
+              else reject(new Error(`Telegram API error: ${parsed.description || 'unknown'}`));
+            } catch (e) {
+              reject(new Error(`Failed to parse response: ${e.message}`));
+            }
+          });
+        });
+
+        req.on('error', reject);
+        req.on('timeout', () => { req.destroy(); reject(new Error('Upload timed out')); });
+        req.write(fullBody);
+        req.end();
+      });
+    },
+
 };
 }