metame-cli 1.5.8 → 1.5.9

package/package.json

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

package/scripts/daemon-bridges.js

@@ -20,11 +20,13 @@ function createBridgeStarter(deps) {
     getSession,
     restoreSessionFromReply,
     handleCommand,
+    pipeline,            // message pipeline for per-chatId serial execution
     pendingActivations,  // optional — used to show smart activation hint
-    activeProcesses,     // optional — used for auto-dispatch to clones
-    messageQueue,        // optional — used for /stop to clear queued messages
+    activeProcesses: _activeProcesses, // legacy — now handled by pipeline
+    messageQueue: _messageQueue,       // legacy — now handled by pipeline
     sendRemoteDispatch,          // optional — send packet to remote peer via relay chat
     handleRemoteDispatchMessage, // optional — intercept relay chat messages
+    getOrCreateWorktree,         // optional — isolated worktree per actor
   } = deps;
 
   async function sendAclReply(bot, chatId, text) {
@@ -278,19 +280,26 @@ function createBridgeStarter(deps) {
     const virtualChatId = `_agent_${member.key}`;
     const parentCwd = member.cwd || boundProj.cwd;
     const resolvedParentCwd = parentCwd.replace(/^~/, require('os').homedir());
-    const memberCwd = _getMemberCwd(resolvedParentCwd, member.key);
+    const memberCwd = typeof getOrCreateWorktree === 'function'
+      ? getOrCreateWorktree(resolvedParentCwd, member.key)
+      : _getMemberCwd(resolvedParentCwd, member.key);
     if (!memberCwd) {
       log('ERROR', `Team [${member.key}] cannot start: directory unavailable`);
       bot.sendMessage(realChatId, `❌ ${member.icon || '🤖'} ${member.name} 启动失败：工作目录创建失败`).catch(() => {});
       return;
     }
     log('INFO', `Team [${member.key}] using cwd: ${memberCwd}`);
+    // Spawn cwd MUST be the actual work directory (worktree/member dir) so that:
+    //   1. Claude CLI operates in the correct directory (git, file edits)
+    //   2. /undo, /redo, /reset target the right repo
+    // Session visibility on desktop is handled by findSessionFile scanning all project dirs,
+    // and by session naming (auto-name with agent label prefix).
     const teamCfg = {
       ...cfg,
       projects: {
         ...(cfg.projects || {}),
         [member.key]: {
-          cwd: memberCwd,
+          cwd: memberCwd,                                    // actual work directory
           name: member.name,
           icon: member.icon || '🤖',
           color: member.color || 'blue',
@@ -299,7 +308,7 @@ function createBridgeStarter(deps) {
       },
     };
     const proxyBot = _createTeamProxyBot(bot, realChatId);
-    handleCommand(proxyBot, virtualChatId, text, teamCfg, executeTaskByName, acl.senderId, acl.readOnly)
+    pipeline.processMessage(virtualChatId, text, { bot: proxyBot, config: teamCfg, executeTaskByName, senderId: acl.senderId, readOnly: acl.readOnly })
       .catch(e => log('ERROR', `Team [${member.key}] error: ${e.message}`));
   }
   // ────────────────────────────────────────────────────────────────────────
@@ -359,7 +368,7 @@ function createBridgeStarter(deps) {
                   bypassAcl: !allowedIds.includes(chatId) && !!isBindCmd,
                 });
                 if (acl.blocked) continue;
-                handleCommand(bot, chatId, cb.data, liveCfg, executeTaskByName, acl.senderId, acl.readOnly).catch(e => {
+                pipeline.processMessage(chatId, cb.data, { bot, config: liveCfg, executeTaskByName, senderId: acl.senderId, readOnly: acl.readOnly }).catch(e => {
                   log('ERROR', `Telegram callback handler error: ${e.message}`);
                 });
               }
@@ -434,7 +443,7 @@ function createBridgeStarter(deps) {
                     continue;
                   }
                 }
-                handleCommand(bot, chatId, prompt, liveCfg, executeTaskByName, acl.senderId, acl.readOnly).catch(e => {
+                pipeline.processMessage(chatId, prompt, { bot, config: liveCfg, executeTaskByName, senderId: acl.senderId, readOnly: acl.readOnly }).catch(e => {
                   log('ERROR', `Telegram file handler error: ${e.message}`);
                 });
               } catch (err) {
@@ -515,16 +524,9 @@ function createBridgeStarter(deps) {
                     const vid = `_agent_${_targetKey}`;
                     const member = _boundProj.team.find(t => t.key === _targetKey);
                     const label = member ? `${member.icon || '🤖'} ${member.name}` : _targetKey;
-                    if (messageQueue.has(vid)) {
-                      const vq = messageQueue.get(vid);
-                      if (vq && vq.timer) clearTimeout(vq.timer);
-                      messageQueue.delete(vid);
-                    }
-                    const vproc = activeProcesses && activeProcesses.get(vid);
-                    if (vproc && vproc.child) {
-                      vproc.aborted = true;
-                      const sig = vproc.killSignal || 'SIGTERM';
-                      try { process.kill(-vproc.child.pid, sig); } catch { try { vproc.child.kill(sig); } catch { /* */ } }
+                    pipeline.clearQueue(vid);
+                    const stopped = pipeline.interruptActive(vid);
+                    if (stopped) {
                       await bot.sendMessage(chatId, `⏹ Stopping ${label}...`);
                     } else {
                       await bot.sendMessage(chatId, `${label} 当前没有活跃任务`);
@@ -577,7 +579,7 @@ function createBridgeStarter(deps) {
                     continue;
                   }
                   try {
-                    await handleCommand(bot, chatId, rest, liveCfg, executeTaskByName, acl.senderId, acl.readOnly);
+                    await pipeline.processMessage(chatId, rest, { bot, config: liveCfg, executeTaskByName, senderId: acl.senderId, readOnly: acl.readOnly });
                   } catch (e) {
                     log('ERROR', `Team main-route handleCommand failed: ${e.message}`);
                     bot.sendMessage(chatId, `❌ 执行失败: ${e.message}`).catch(() => {});
@@ -597,7 +599,7 @@ function createBridgeStarter(deps) {
               }
 
               // Default: route to main project
-              handleCommand(bot, chatId, text, liveCfg, executeTaskByName, acl.senderId, acl.readOnly).catch(e => {
+              pipeline.processMessage(chatId, text, { bot, config: liveCfg, executeTaskByName, senderId: acl.senderId, readOnly: acl.readOnly }).catch(e => {
                 log('ERROR', `Telegram handler error: ${e.message}`);
               });
             }
@@ -727,7 +729,7 @@ function createBridgeStarter(deps) {
                 return;
               }
             }
-            await handleCommand(bot, chatId, prompt, liveCfg, executeTaskByName, acl.senderId, acl.readOnly);
+            await pipeline.processMessage(chatId, prompt, { bot, config: liveCfg, executeTaskByName, senderId: acl.senderId, readOnly: acl.readOnly });
           } catch (err) {
             log('ERROR', `Feishu file download failed: ${err.message}`);
             await bot.sendMessage(chatId, `❌ Download failed: ${err.message}`);
@@ -816,17 +818,9 @@ function createBridgeStarter(deps) {
                 const vid = `_agent_${_targetKey}`;
                 const member = _boundProj.team.find(t => t.key === _targetKey);
                 const label = member ? `${member.icon || '🤖'} ${member.name}` : _targetKey;
-                // Clear message queue for this virtual agent
-                if (messageQueue.has(vid)) {
-                  const vq = messageQueue.get(vid);
-                  if (vq && vq.timer) clearTimeout(vq.timer);
-                  messageQueue.delete(vid);
-                }
-                const vproc = activeProcesses && activeProcesses.get(vid);
-                if (vproc && vproc.child) {
-                  vproc.aborted = true;
-                  const sig = vproc.killSignal || 'SIGTERM';
-                  try { process.kill(-vproc.child.pid, sig); } catch { try { vproc.child.kill(sig); } catch { /* */ } }
+                pipeline.clearQueue(vid);
+                const stopped = pipeline.interruptActive(vid);
+                if (stopped) {
                   await bot.sendMessage(chatId, `⏹ Stopping ${label}...`);
                 } else {
                   await bot.sendMessage(chatId, `${label} 当前没有活跃任务`);
@@ -902,7 +896,7 @@ function createBridgeStarter(deps) {
                     return;
                   }
               try {
-                await handleCommand(bot, chatId, rest, liveCfg, executeTaskByName, acl.senderId, acl.readOnly);
+                await pipeline.processMessage(chatId, rest, { bot, config: liveCfg, executeTaskByName, senderId: acl.senderId, readOnly: acl.readOnly });
               } catch (e) {
                 log('ERROR', `Team main-route handleCommand failed: ${e.message}`);
                 bot.sendMessage(chatId, `❌ 执行失败: ${e.message}`).catch(() => {});
@@ -922,7 +916,12 @@ function createBridgeStarter(deps) {
 
           }
 
-          await handleCommand(bot, chatId, text, liveCfg, executeTaskByName, acl.senderId, acl.readOnly);
+          try {
+            await pipeline.processMessage(chatId, text, { bot, config: liveCfg, executeTaskByName, senderId: acl.senderId, readOnly: acl.readOnly });
+          } catch (e) {
+            log('ERROR', `Feishu handleCommand failed for ${chatId}: ${e.message}`);
+            bot.sendMessage(chatId, `❌ 命令执行失败: ${e.message}`).catch(() => {});
+          }
         }
       }, { log: (lvl, msg) => log(lvl, msg) });
 
@@ -1071,16 +1070,9 @@ function createBridgeStarter(deps) {
                 const vid = `_agent_${_targetKey}`;
                 const member = _boundProj.team.find(t => t.key === _targetKey);
                 const label = member ? `${member.icon || '🤖'} ${member.name}` : _targetKey;
-                if (messageQueue.has(vid)) {
-                  const vq = messageQueue.get(vid);
-                  if (vq && vq.timer) clearTimeout(vq.timer);
-                  messageQueue.delete(vid);
-                }
-                const vproc = activeProcesses && activeProcesses.get(vid);
-                if (vproc && vproc.child) {
-                  vproc.aborted = true;
-                  const sig = vproc.killSignal || 'SIGTERM';
-                  try { process.kill(-vproc.child.pid, sig); } catch { try { vproc.child.kill(sig); } catch { /* */ } }
+                pipeline.clearQueue(vid);
+                const stopped = pipeline.interruptActive(vid);
+                if (stopped) {
                   await bot.sendMessage(chatId, `Stopping ${label}...`);
                 } else {
                   await bot.sendMessage(chatId, `${label} 当前没有活跃任务`);
@@ -1132,7 +1124,7 @@ function createBridgeStarter(deps) {
             }
           }
 
-          handleCommand(bot, chatId, commandText, liveCfg, executeTaskByName, sender, false)
+          pipeline.processMessage(chatId, commandText, { bot, config: liveCfg, executeTaskByName, senderId: sender, readOnly: false })
             .catch(e => log('ERROR', `[IMESSAGE] handleCommand error: ${e.message}`));
         }
       } catch (e) {

package/scripts/daemon-checkpoints.js

@@ -1,12 +1,23 @@
 'use strict';
 
 function createCheckpointUtils(deps) {
-  const { execSync, execFile, path, log } = deps;
+  const { execSync: _execSync, execFile, path, log } = deps;
   const { promisify } = require('util');
   const execFileAsync = execFile ? promisify(execFile) : null;
 
   const CHECKPOINT_PREFIX = '[metame-checkpoint]';
   const CHECKPOINT_REF_PREFIX = 'refs/metame/checkpoints/';
+
+  // Build the ref path for a checkpoint.
+  // When agentKey is provided: refs/metame/checkpoints/<agentKey>/<ts>
+  // Otherwise:                 refs/metame/checkpoints/<ts>  (backward compat)
+  function _checkpointRef(ts, agentKey) {
+    if (agentKey && String(agentKey).trim()) {
+      const safe = String(agentKey).replace(/[^a-zA-Z0-9_\-]/g, '_').slice(0, 60);
+      return `${CHECKPOINT_REF_PREFIX}${safe}/${ts}`;
+    }
+    return `${CHECKPOINT_REF_PREFIX}${ts}`;
+  }
   const MAX_CHECKPOINTS = 20;
 
   function cpExtractTimestamp(message) {
@@ -50,41 +61,41 @@ function createCheckpointUtils(deps) {
     return { ts, safeLabel, msg: `${CHECKPOINT_PREFIX}${safeLabel} (${ts})` };
   }
 
-  // Build a checkpoint commit stored under refs/metame/checkpoints/{ts} — never pushed by git push.
+  // Build a checkpoint commit stored under refs/metame/checkpoints/{agentKey}/{ts} — never pushed by git push.
   // Returns the commit SHA, or null if nothing changed.
-  function gitCheckpoint(cwd, label) {
+  function gitCheckpoint(cwd, label, agentKey) {
+    const { execFileSync } = require('child_process');
     try {
-      execSync('git rev-parse --is-inside-work-tree', { cwd, stdio: 'ignore', ...WIN_HIDE });
+      execFileSync('git', ['rev-parse', '--is-inside-work-tree'], { cwd, stdio: 'ignore', ...WIN_HIDE });
 
       // Snapshot current index so we can restore it after staging
-      const originalTree = execSync('git write-tree', { cwd, encoding: 'utf8', timeout: 3000, ...WIN_HIDE }).trim();
+      const originalTree = execFileSync('git', ['write-tree'], { cwd, encoding: 'utf8', timeout: 3000, ...WIN_HIDE }).toString().trim();
 
       // Stage everything to get a full snapshot tree
-      execSync('git add -A', { cwd, stdio: 'ignore', timeout: 5000, ...WIN_HIDE });
-      const cpTree = execSync('git write-tree', { cwd, encoding: 'utf8', timeout: 3000, ...WIN_HIDE }).trim();
+      execFileSync('git', ['add', '-A'], { cwd, stdio: 'ignore', timeout: 5000, ...WIN_HIDE });
+      const cpTree = execFileSync('git', ['write-tree'], { cwd, encoding: 'utf8', timeout: 3000, ...WIN_HIDE }).toString().trim();
 
       // Restore index immediately — leave the user's staged state intact
-      execSync(`git read-tree ${originalTree}`, { cwd, stdio: 'ignore', timeout: 3000, ...WIN_HIDE });
+      execFileSync('git', ['read-tree', originalTree], { cwd, stdio: 'ignore', timeout: 3000, ...WIN_HIDE });
 
       // Compare against HEAD tree — skip if nothing changed
       let headTree = '';
-      try { headTree = execSync('git rev-parse HEAD^{tree}', { cwd, encoding: 'utf8', timeout: 3000, ...WIN_HIDE }).trim(); } catch { /* no commits yet */ }
+      try { headTree = execFileSync('git', ['rev-parse', 'HEAD^{tree}'], { cwd, encoding: 'utf8', timeout: 3000, ...WIN_HIDE }).toString().trim(); } catch { /* no commits yet */ }
       if (cpTree === headTree) return null;
 
       const { ts, safeLabel, msg } = buildCheckpointMsg(label);
 
-      // Build parent arg (-p HEAD, or nothing for initial commit)
-      let parentFlag = '';
-      try { parentFlag = `-p ${execSync('git rev-parse HEAD', { cwd, encoding: 'utf8', timeout: 3000, ...WIN_HIDE }).trim()}`; } catch { /* no HEAD */ }
+      // Build parent args (-p HEAD, or empty for initial commit)
+      let parentArgs = [];
+      try { parentArgs = ['-p', execFileSync('git', ['rev-parse', 'HEAD'], { cwd, encoding: 'utf8', timeout: 3000, ...WIN_HIDE }).toString().trim()]; } catch { /* no HEAD */ }
 
       // Create an orphaned commit object — NOT on any branch
-      const cpSha = execSync(
-        `git commit-tree ${cpTree} ${parentFlag} -m "${msg}"`,
+      const cpSha = execFileSync('git', ['commit-tree', cpTree, ...parentArgs, '-m', msg],
         { cwd, encoding: 'utf8', timeout: 10000, ...WIN_HIDE }
-      ).trim();
+      ).toString().trim();
 
       // Point a local-only ref at it — git push never transfers refs/metame/*
-      execSync(`git update-ref ${CHECKPOINT_REF_PREFIX}${ts} ${cpSha}`, { cwd, stdio: 'ignore', timeout: 3000, ...WIN_HIDE });
+      execFileSync('git', ['update-ref', _checkpointRef(ts, agentKey), cpSha], { cwd, stdio: 'ignore', timeout: 3000, ...WIN_HIDE });
 
       log('INFO', `Git checkpoint: ${cpSha.slice(0, 8)} in ${path.basename(cwd)}${safeLabel}`);
       return cpSha;
@@ -94,8 +105,8 @@ function createCheckpointUtils(deps) {
   }
 
   // Async version: same logic but non-blocking.
-  async function gitCheckpointAsync(cwd, label) {
-    if (!execFileAsync) return gitCheckpoint(cwd, label);
+  async function gitCheckpointAsync(cwd, label, agentKey) {
+    if (!execFileAsync) return gitCheckpoint(cwd, label, agentKey);
     try {
       await execFileAsync('git', ['rev-parse', '--is-inside-work-tree'], { cwd, timeout: 3000, ...WIN_HIDE });
 
@@ -121,7 +132,7 @@ function createCheckpointUtils(deps) {
       const { stdout: cpShaOut } = await execFileAsync('git', ['commit-tree', cpTree, ...parentArgs, '-m', msg], { cwd, encoding: 'utf8', timeout: 10000, ...WIN_HIDE });
       const cpSha = cpShaOut.trim();
 
-      await execFileAsync('git', ['update-ref', `${CHECKPOINT_REF_PREFIX}${ts}`, cpSha], { cwd, timeout: 3000, ...WIN_HIDE });
+      await execFileAsync('git', ['update-ref', _checkpointRef(ts, agentKey), cpSha], { cwd, timeout: 3000, ...WIN_HIDE });
 
       log('INFO', `Git checkpoint: ${cpSha.slice(0, 8)} in ${path.basename(cwd)}${safeLabel}`);
       return cpSha;
@@ -133,11 +144,13 @@ function createCheckpointUtils(deps) {
   // List checkpoints, newest first. Returns [{hash, message, ref, parentHash}].
   // Uses %(parent) in for-each-ref format — no extra subprocess per checkpoint.
   function listCheckpoints(cwd, limit = 20) {
+    const { execFileSync } = require('child_process');
     try {
-      const raw = execSync(
-        `git for-each-ref --sort=-committerdate --format="%(objectname)|%(refname)|%(parent)|%(contents:subject)" --count=${limit} ${CHECKPOINT_REF_PREFIX}`,
-        { cwd, encoding: 'utf8', timeout: 5000, ...WIN_HIDE }
-      ).trim();
+      const raw = execFileSync('git', [
+        'for-each-ref', '--sort=-committerdate',
+        `--format=%(objectname)|%(refname)|%(parent)|%(contents:subject)`,
+        `--count=${limit}`, CHECKPOINT_REF_PREFIX,
+      ], { cwd, encoding: 'utf8', timeout: 5000, ...WIN_HIDE }).toString().trim();
       if (!raw) return [];
       return raw.split('\n').filter(Boolean).map(line => {
         const [hash, ref, parent, ...rest] = line.split('|');
@@ -148,12 +161,13 @@ function createCheckpointUtils(deps) {
 
   // Delete checkpoints beyond MAX_CHECKPOINTS (oldest first).
   function cleanupCheckpoints(cwd) {
+    const { execFileSync } = require('child_process');
     try {
       const all = listCheckpoints(cwd, 100);
       if (all.length <= MAX_CHECKPOINTS) return;
       const toDelete = all.slice(MAX_CHECKPOINTS); // oldest (for-each-ref sorted newest-first)
       for (const cp of toDelete) {
-        try { execSync(`git update-ref -d ${cp.ref}`, { cwd, stdio: 'ignore', timeout: 3000, ...WIN_HIDE }); } catch { /* ignore */ }
+        try { execFileSync('git', ['update-ref', '-d', cp.ref], { cwd, stdio: 'ignore', timeout: 3000, ...WIN_HIDE }); } catch { /* ignore */ }
       }
       log('INFO', `Cleaned up ${toDelete.length} old checkpoints in ${path.basename(cwd)}`);
     } catch { /* ignore */ }