metame-cli 1.5.25 → 1.6.0

package/scripts/daemon-bridges.js

@@ -24,6 +24,7 @@ function createBridgeStarter(deps) {
     saveState,
     getSession,
     restoreSessionFromReply,
+    releaseWarmPool,
     handleCommand,
     pipeline,            // message pipeline for per-chatId serial execution
     pendingActivations,  // optional — used to show smart activation hint
@@ -224,6 +225,21 @@ function createBridgeStarter(deps) {
       },
     });
   }
+
+  function _createPipelineTarget({ pipelineChatId, effectiveChatId, bot }) {
+    const replyChatId = String(pipelineChatId || '').trim();
+    const processChatId = String(effectiveChatId || pipelineChatId || '').trim();
+    if (!replyChatId || !processChatId) {
+      return { processChatId: replyChatId || processChatId, bot };
+    }
+    if (replyChatId === processChatId) {
+      return { processChatId, bot };
+    }
+    return {
+      processChatId,
+      bot: _createTeamProxyBot(bot, replyChatId),
+    };
+  }
   // Get team member's working directory inside the source tree, never under ~/.metame.
   // Creates agents/<key>/ directory by default, or ensures an explicit member.cwd exists.
   function _getMemberCwd(parentCwd, key, explicitCwd = null) {
@@ -862,6 +878,11 @@ function createBridgeStarter(deps) {
               }
               if (mapped.id) {
                 log('INFO', `Session restored via reply: ${mapped.id.slice(0, 8)} (${path.basename(mapped.cwd)})`);
+                // Evict warm process so next spawn uses --resume with the restored session
+                if (typeof releaseWarmPool === 'function') {
+                  const _logicalKey = String(mapped.logicalChatId || '').trim();
+                  if (_logicalKey) releaseWarmPool(_logicalKey);
+                }
               }
               _replyAgentKey = mapped.agentKey || null;
             } else {
@@ -871,12 +892,29 @@ function createBridgeStarter(deps) {
             _replyMappingFound = true;
             _replyAgentKey = _parentMapping.agentKey || null;
             log('INFO', `Feishu topic inherited root mapping agentKey=${_replyAgentKey || 'main'} parentId=${parentId}`);
+            // Restore session from topic root (same as quoted reply) so 指定回复 resumes context
+            if (_parentMapping.id && typeof restoreSessionFromReply === 'function') {
+              restoreSessionFromReply(chatId, _parentMapping);
+              log('INFO', `Session restored via topic root: ${_parentMapping.id.slice(0, 8)} (${path.basename(_parentMapping.cwd || '~')})`);
+              // Evict warm process so next spawn uses --resume with the restored session
+              if (typeof releaseWarmPool === 'function') {
+                const _logicalKey = String(_parentMapping.logicalChatId || '').trim();
+                if (_logicalKey) releaseWarmPool(_logicalKey);
+              }
+            }
           }
 
           // Helper: set/clear sticky on shared state object and persist
           // Use pipelineChatId so each topic gets independent sticky state
           const _chatKey = String(pipelineChatId);
           const _rawChatKey = _threadRawChatId(_chatKey);
+          const _topicMainRoute = !!(
+            threadRootId
+            && _parentMapping
+            && !_isQuotedReply
+            && _parentMapping.logicalChatId
+            && !String(_parentMapping.logicalChatId).startsWith('_agent_')
+          );
           const _setSticky = (key) => {
             if (!_st.team_sticky) _st.team_sticky = {};
             _st.team_sticky[_chatKey] = key;
@@ -899,6 +937,11 @@ function createBridgeStarter(deps) {
             saveState(_st);
           };
           let _stickyKey = (_st.team_sticky || {})[_chatKey] || (_st.team_sticky || {})[_rawChatKey] || null;
+          const _pipelineTarget = _createPipelineTarget({
+            pipelineChatId,
+            effectiveChatId: _topicMainRoute ? chatId : pipelineChatId,
+            bot,
+          });
 
           // Team group routing: if bound project has a team array, check message for member nickname
           // Non-/stop slash commands bypass team routing → handled by main project
@@ -978,7 +1021,13 @@ function createBridgeStarter(deps) {
               // Cases b & c: no agentKey (main agent) or stale/unknown agentKey
               _clearSticky();
               log('INFO', `Quoted reply → route to main (agentKey=${_replyAgentKey} mappingFound=${_replyMappingFound})`);
-              await pipeline.processMessage(pipelineChatId, trimmedText, { bot, config: liveCfg, executeTaskByName, senderId: acl.senderId, readOnly: acl.readOnly });
+              await pipeline.processMessage(_pipelineTarget.processChatId, trimmedText, {
+                bot: _pipelineTarget.bot,
+                config: liveCfg,
+                executeTaskByName,
+                senderId: acl.senderId,
+                readOnly: acl.readOnly,
+              });
               return;
             }
             // 1. Explicit nickname → route + set sticky
@@ -1034,7 +1083,13 @@ function createBridgeStarter(deps) {
                     return;
                   }
               try {
-                await pipeline.processMessage(pipelineChatId, rest, { bot, config: liveCfg, executeTaskByName, senderId: acl.senderId, readOnly: acl.readOnly });
+                await pipeline.processMessage(_pipelineTarget.processChatId, rest, {
+                  bot: _pipelineTarget.bot,
+                  config: liveCfg,
+                  executeTaskByName,
+                  senderId: acl.senderId,
+                  readOnly: acl.readOnly,
+                });
               } catch (e) {
                 log('ERROR', `Team main-route handleCommand failed: ${e.message}`);
                 bot.sendMessage(pipelineChatId, `❌ 执行失败: ${e.message}`).catch(() => {});
@@ -1058,7 +1113,13 @@ function createBridgeStarter(deps) {
           }
 
           try {
-            await pipeline.processMessage(pipelineChatId, text, { bot, config: liveCfg, executeTaskByName, senderId: acl.senderId, readOnly: acl.readOnly });
+            await pipeline.processMessage(_pipelineTarget.processChatId, text, {
+              bot: _pipelineTarget.bot,
+              config: liveCfg,
+              executeTaskByName,
+              senderId: acl.senderId,
+              readOnly: acl.readOnly,
+            });
           } catch (e) {
             log('ERROR', `Feishu handleCommand failed for ${chatId}: ${e.message}`);
             bot.sendMessage(pipelineChatId, `❌ 命令执行失败: ${e.message}`).catch(() => {});

package/scripts/daemon-claude-engine.js

@@ -10,7 +10,7 @@ const {
   _private: { resolveCodexPermissionProfile },
 } = require('./daemon-engine-runtime');
 const { rawChatId } = require('./core/thread-chat-id');
-const { buildAgentContextForEngine, buildMemorySnapshotContent, refreshMemorySnapshot } = require('./agent-layer');
+const { buildAgentContextForEngine, buildMemorySnapshotContent, selectSnapshotContext, refreshMemorySnapshot } = require('./agent-layer');
 const {
   adaptDaemonHintForEngine,
   buildAgentHint,
@@ -84,6 +84,7 @@ function createClaudeEngine(deps) {
     isContentFile,
     sendFileButtons,
     findSessionFile,
+    listRecentSessions,
     getSession,
     getSessionForEngine,
     createSession,
@@ -102,6 +103,7 @@ function createClaudeEngine(deps) {
     touchInteraction,
     statusThrottleMs = 3000,
     fallbackThrottleMs = 8000,
+    autoSyncMinGapMs = 60_000,
     getEngineRuntime: injectedGetEngineRuntime,
     getDefaultEngine: _getDefaultEngine,
     warmPool,
@@ -1362,6 +1364,36 @@ function createClaudeEngine(deps) {
         await patchSessionSerialized(sessionChatId, (cur) => ({ ...cur, cwd: effectiveCwd }));
       }
 
+      // Auto-sync: when daemon is idle (no warm process), check if a newer Claude session exists
+      // in the project directory (e.g., created from Claude Code CLI on the same computer).
+      // This keeps phone (Feishu/mobile) and computer (Claude Code CLI) sessions in sync.
+      const _hasWarm = !!(warmPool && typeof warmPool.hasWarm === 'function' && warmPool.hasWarm(sessionChatId));
+      if (runtime.name === 'claude' && !String(sessionChatId).startsWith('_agent_') &&
+          !_hasWarm && session.started && session.id && session.id !== '__continue__' && session.cwd) {
+        const _recentInProject = typeof listRecentSessions === 'function'
+          ? listRecentSessions(2, session.cwd, 'claude') : [];
+        const _currentMtime = (() => {
+          try {
+            const _f = typeof findSessionFile === 'function' ? findSessionFile(session.id) : null;
+            return _f ? fs.statSync(_f).mtimeMs : 0;
+          } catch { return 0; }
+        })();
+        const _newerSession = _recentInProject.find(
+          s => s.sessionId !== session.id && (s.fileMtime || 0) - _currentMtime > autoSyncMinGapMs
+        );
+        if (_newerSession) {
+          const _gapSec = Math.round(((_newerSession.fileMtime || 0) - _currentMtime) / 1000);
+          log('INFO', `[AutoSync] ${String(sessionChatId).slice(-8)}: switching ${session.id.slice(0, 8)} -> ${_newerSession.sessionId.slice(0, 8)} (newer by ${_gapSec}s)`);
+          await patchSessionSerialized(sessionChatId, (cur) => {
+            const _engines = { ...(cur.engines || {}) };
+            _engines.claude = { ...(_engines.claude || {}), id: _newerSession.sessionId, started: true };
+            return { ...cur, engines: _engines };
+          });
+          session = { ...session, id: _newerSession.sessionId };
+          bot.sendMessage(chatId, `🔄 已自动同步到最新 session：\`${_newerSession.sessionId.slice(0, 8)}\``).catch(() => { });
+        }
+      }
+
       // Warm pool: check if a persistent process is available for this session (Claude only).
       // Declared early so downstream logic can skip expensive operations when reusing warm process.
       const _warmSessionKey = sessionChatId;
@@ -2148,14 +2180,30 @@ function createClaudeEngine(deps) {
         if (dispatchedTargets.length > 0) {
           const allProjects = (config && config.projects) || {};
           const names = dispatchedTargets.map(k => (allProjects[k] && allProjects[k].name) || k).join('、');
-          const doneMsg = await bot.sendMessage(chatId, `✉️ 已转达给 ${names}，处理中…`);
+          const fwdText = `✉️ 已转达给 ${names}，处理中…`;
+          let doneMsg;
+          if (statusMsgId && bot.editMessage) {
+            await bot.editMessage(chatId, statusMsgId, fwdText, _ackCardHeader).catch(() => {});
+            doneMsg = { message_id: statusMsgId };
+          } else {
+            if (statusMsgId && bot.deleteMessage) bot.deleteMessage(chatId, statusMsgId).catch(() => {});
+            doneMsg = await bot.sendMessage(chatId, fwdText);
+          }
           if (doneMsg && doneMsg.message_id && session) trackMsgSession(doneMsg.message_id, session, projectKeyFromVirtualChatId(chatId));
           const wasNew = !session.started;
           if (wasNew) markSessionStarted(sessionChatId, engineName);
           return { ok: true };
         }
         const filesDesc = files && files.length > 0 ? `\n修改了 ${files.length} 个文件` : '';
-        const doneMsg = await bot.sendMessage(chatId, `✅ 完成${filesDesc}`);
+        const doneText = `✅ 完成${filesDesc}`;
+        let doneMsg;
+        if (statusMsgId && bot.editMessage) {
+          await bot.editMessage(chatId, statusMsgId, doneText, _ackCardHeader).catch(() => {});
+          doneMsg = { message_id: statusMsgId };
+        } else {
+          if (statusMsgId && bot.deleteMessage) bot.deleteMessage(chatId, statusMsgId).catch(() => {});
+          doneMsg = await bot.sendMessage(chatId, doneText);
+        }
         if (doneMsg && doneMsg.message_id && session) trackMsgSession(doneMsg.message_id, session, projectKeyFromVirtualChatId(chatId));
         const wasNew = !session.started;
         if (wasNew) markSessionStarted(sessionChatId, engineName);
@@ -2338,12 +2386,18 @@ function createClaudeEngine(deps) {
           setImmediate(async () => {
             try {
               const memory = require('./memory');
-              const pKey = boundProjectKey || '';
-              const sessions = memory.recentSessions({ limit: 5, project: pKey });
-              const factsRaw = memory.searchFacts('', { limit: 10, project: pKey });
-              const facts = Array.isArray(factsRaw) ? factsRaw : [];
+              const snapshotCtx = selectSnapshotContext(memory, {
+                projectHints: [
+                  boundProjectKey,
+                  boundProject.project_key,
+                  boundProject.name,
+                  boundProject.agent_id,
+                ],
+                sessionLimit: 5,
+                factLimit: 10,
+              });
               memory.close();
-              const snapshotContent = buildMemorySnapshotContent(sessions, facts);
+              const snapshotContent = buildMemorySnapshotContent(snapshotCtx.sessions, snapshotCtx.facts);
               const agentId = boundProject.agent_id;
               if (refreshMemorySnapshot(agentId, snapshotContent, HOME)) {
                 log('DEBUG', `[AGENT] Memory snapshot refreshed for ${agentId}`);

package/scripts/daemon-command-router.js

@@ -3,6 +3,7 @@
 const { resolveEngineModel } = require('./daemon-engine-runtime');
 const { createAgentIntentHandler } = require('./daemon-agent-intent');
 const { rawChatId: extractOriginalChatId, isThreadChatId } = require('./core/thread-chat-id');
+const { createWikiCommandHandler } = require('./daemon-wiki');
 
 function createCommandRouter(deps) {
   const {
@@ -30,6 +31,7 @@ function createCommandRouter(deps) {
     pendingActivations,
     agentFlowTtlMs,
     getDefaultEngine,
+    getDb,              // optional — () → DatabaseSync (for wiki commands)
   } = deps;
 
 
@@ -462,6 +464,19 @@ function createCommandRouter(deps) {
       return;
     }
 
+    // /wiki — knowledge wiki commands
+    if (text.startsWith('/wiki') && getDb) {
+      const wikiProviders = providerMod ? {
+        callHaiku: (...args) => providerMod.callHaiku(...args),
+        buildDistillEnv: (...args) => providerMod.buildDistillEnv(...args),
+      } : null;
+      const wikiOutputDir = config && config.daemon && config.daemon.wiki_output_dir
+        ? config.daemon.wiki_output_dir.replace(/^~/, process.env.HOME || '')
+        : null;
+      const { handleWikiCommand } = createWikiCommandHandler({ getDb, providers: wikiProviders, wikiOutputDir, log });
+      if (await handleWikiCommand({ bot, chatId, text })) return;
+    }
+
     // /btw — quick side question (read-only, concise, bypasses cooldown)
     if (/^\/btw(\s|$)/i.test(text)) {
       const btwQuestion = text.replace(/^\/btw\s*/i, '').trim();

package/scripts/daemon-default.yaml

@@ -55,7 +55,6 @@ heartbeat:
       type: script
       command: node ~/.metame/distill.js
       interval: 4h
-      timeout: 5m
       precondition: "test -s ~/.metame/raw_signals.jsonl"
       require_idle: true
       notify: false
@@ -85,7 +84,6 @@ heartbeat:
       type: script
       command: node ~/.metame/skill-evolution.js
       interval: 12h
-      timeout: 5m
       precondition: "test -s ~/.metame/skill_signals.jsonl"
       require_idle: true
       notify: false
@@ -116,7 +114,7 @@ heartbeat:
       at: "01:30"
       require_idle: true
       notify: false
-      enabled: false
+      enabled: true
 
     # Legacy flat tasks (no project isolation). New tasks should go under projects: above.
     # Examples — uncomment or add your own:
@@ -166,6 +164,7 @@ budget:
 daemon:
   model: sonnet  # sonnet, opus, haiku — model for mobile sessions
   log_max_size: 1048576
+  wiki_output_dir: ~/Documents/ObsidianVault/MetaMe/wiki  # Obsidian vault wiki subdirectory
   heartbeat_check_interval: 60
   # Skip all permission prompts for mobile sessions (full access)
   # Mobile users can't click "allow" — so we pre-authorize everything.

package/scripts/daemon-ops-commands.js

@@ -87,30 +87,22 @@ function createOpsCommandHandler(deps) {
         }
         try {
           let diffFiles = '';
-          let diffFailed = false;
           const _wh = process.platform === 'win32' ? { windowsHide: true } : {};
-          try { diffFiles = execSync(`git diff --name-only HEAD ${match.hash}`, { cwd, encoding: 'utf8', timeout: 5000, ..._wh }).trim(); } catch { diffFailed = true; }
+          try { diffFiles = execSync(`git diff --name-only HEAD ${match.hash}`, { cwd, encoding: 'utf8', timeout: 5000, ..._wh }).trim(); } catch { }
           const changedFiles = diffFiles ? diffFiles.split('\n').filter(Boolean) : [];
-          if (changedFiles.length > 0 || diffFailed) {
-            // Save current state before rollback (safety net)
-            gitCheckpoint(cwd, '[metame-safety] before rollback');
-            // Reset HEAD to checkpoint's parent (removes any commits Claude made)
-            if (match.parentHash) {
-              execSync(`git reset --hard ${match.parentHash}`, { cwd, stdio: 'ignore', timeout: 10000, ..._wh });
-            }
-            // Restore only changed files (not entire worktree) to preserve user's manual edits
-            if (changedFiles.length > 0) {
-              execFileSync('git', ['checkout', match.hash, '--', ...changedFiles], { cwd, stdio: 'ignore', timeout: 10000 });
-            } else {
-              // diff failed but we still reset — fallback to full restore
-              execFileSync('git', ['checkout', match.hash, '--', '.'], { cwd, stdio: 'ignore', timeout: 10000 });
-            }
+          // Reset HEAD to checkpoint's parent (removes any commits Claude made)
+          if (match.parentHash) {
+            execSync(`git reset --hard ${match.parentHash}`, { cwd, stdio: 'ignore', timeout: 10000, ..._wh });
+          }
+          // Restore only files touched between the checkpoint and HEAD; unrelated user edits must survive.
+          if (changedFiles.length > 0) {
+            execFileSync('git', ['checkout', match.hash, '--', ...changedFiles], { cwd, stdio: 'ignore', timeout: 10000 });
           }
           // Truncate context to checkpoint time (covers multi-turn rollback)
           truncateSessionToCheckpoint(session.id, match.message);
+          const fileList = changedFiles.map(f => path.basename(f)).join(', ');
           const fileCount = changedFiles.length;
           let msg = `⏪ 已回退到 ${cpDisplayLabel(match.message)}`;
-          const fileList = changedFiles.map(f => path.basename(f)).join(', ');
           if (fileCount > 0) msg += `\n📁 ${fileCount} 个文件恢复: ${fileList}`;
           log('INFO', `/undo <hash> executed for ${chatId}: reset to ${match.hash.slice(0, 8)}, files=${fileCount}`);
           await bot.sendMessage(chatId, msg);
@@ -251,7 +243,6 @@ function createOpsCommandHandler(deps) {
                 if (cpMatch.parentHash) {
                   execSync(`git reset --hard ${cpMatch.parentHash}`, { cwd: cwd2, stdio: 'ignore', timeout: 10000, ..._wh2 });
                 }
-                // Restore only changed files (not entire worktree) to preserve user's manual edits
                 execFileSync('git', ['checkout', cpMatch.hash, '--', ...changedFiles2], { cwd: cwd2, stdio: 'ignore', timeout: 10000 });
                 gitMsg2 = `\n📁 ${changedFiles2.length} 个文件已恢复`;
                 cleanupCheckpoints(cwd2);

package/scripts/daemon-session-commands.js

@@ -36,6 +36,7 @@ function createSessionCommandHandler(deps) {
     getSessionRecentContext,
     getSessionRecentDialogue,
     getDefaultEngine = () => 'claude',
+    releaseWarmPool,
   } = deps;
 
   function normalizeEngineName(name) {
@@ -412,10 +413,13 @@ function createSessionCommandHandler(deps) {
         return true;
       }
 
+      const sessionKeyForWarm = getSessionRoute(chatId).sessionChatId;
       const state2 = loadState();
       const targetEngine = normalizeEngineName(target.engine) || getCurrentEngine(chatId);
       const attached = attachResolvedTarget(state2, chatId, targetEngine, target, target.projectPath || HOME);
       saveState(state2);
+      // Evict warm process so next spawn uses --resume <new-session-id>
+      if (typeof releaseWarmPool === 'function') releaseWarmPool(sessionKeyForWarm);
 
       const recentCtx = typeof getSessionRecentContext === 'function'
         ? getSessionRecentContext(target.sessionId)

package/scripts/daemon-warm-pool.js

@@ -161,6 +161,20 @@ function createWarmPool(deps) {
     }
   }
 
+  /**
+   * Non-destructive validity check. Returns true if a live warm process exists for the key.
+   * Mirrors acquireWarm's dead-process checks without consuming the entry.
+   */
+  function hasWarm(sessionKey) {
+    const entry = pool.get(sessionKey);
+    if (!entry) return false;
+    if (entry.child.killed || entry.child.exitCode !== null) {
+      _cleanup(sessionKey);
+      return false;
+    }
+    return true;
+  }
+
   /**
    * Build the stream-json user message for stdin.
    */
@@ -179,6 +193,7 @@ function createWarmPool(deps) {
     releaseWarm,
     releaseAll,
     buildStreamMessage,
+    hasWarm,
     _pool: pool,
   };
 }