metame-cli 1.5.8 → 1.5.10

package/scripts/daemon-claude-engine.js

@@ -77,6 +77,7 @@ function createClaudeEngine(deps) {
     fallbackThrottleMs = 8000,
     getEngineRuntime: injectedGetEngineRuntime,
     getDefaultEngine: _getDefaultEngine,
+    warmPool,
   } = deps;
   function getDefaultEngine() {
     return (typeof _getDefaultEngine === 'function') ? _getDefaultEngine() : 'claude';
@@ -103,6 +104,10 @@ function createClaudeEngine(deps) {
     }
     return true;
   }
+  // Card reuse for merge-pause: when a task is paused for message merging,
+  // save the statusMsgId so the next askClaude reuses the same card.
+  const _pausedCards = new Map(); // chatId -> { statusMsgId, cardHeader }
+
   let mentorEngine = null;
   try { mentorEngine = require('./mentor-engine'); } catch { /* optional */ }
   let sessionAnalytics = null;
@@ -110,6 +115,9 @@ function createClaudeEngine(deps) {
 
   function shouldAutoRouteSkill({ agentMatch, hasActiveSession, boundProjectKey, skillName }) {
     if (agentMatch || hasActiveSession) return false;
+    // Dedicated agent chats (Munger, Jia, etc.) must never be hijacked by skill routing.
+    // agentMatch is null for strict-bound chats (by design), so we guard on boundProjectKey.
+    if (boundProjectKey && String(boundProjectKey).trim() !== 'personal') return false;
     if (
       String(boundProjectKey || '').trim() === 'personal'
       && String(skillName || '').trim() === 'macos-local-orchestrator'
@@ -390,7 +398,19 @@ function createClaudeEngine(deps) {
     return null;
   }
 
-  function inspectClaudeResumeSession(session) {
+  // Map full API model IDs back to their CLI alias family.
+  // When the configured model is an alias (e.g. "sonnet") and the JSONL records the full ID
+  // (e.g. "claude-sonnet-4-6"), they are the same family — no pin needed.
+  // This prevents pinning to a deprecated/retired full model name.
+  function _modelFamilyAlias(fullModelId) {
+    const m = String(fullModelId || '').toLowerCase();
+    if (m.includes('opus')) return 'opus';
+    if (m.includes('sonnet')) return 'sonnet';
+    if (m.includes('haiku')) return 'haiku';
+    return null;
+  }
+
+  function inspectClaudeResumeSession(session, configuredModel) {
     const result = {
       shouldResume: true,
       modelPin: null,
@@ -412,11 +432,25 @@ function createClaudeEngine(deps) {
             reason: 'non-claude-session',
           };
         }
-        return {
-          shouldResume: true,
-          modelPin: sessionModel,
-          reason: '',
-        };
+        // If the configured model is a short alias (sonnet/opus/haiku) and the JSONL model
+        // belongs to the same family, do NOT pin — let the alias resolve to the latest version.
+        // Only pin when the families genuinely differ (e.g. session was opus, config says sonnet).
+        const sessionFamily = _modelFamilyAlias(sessionModel);
+        const configFamily = _modelFamilyAlias(configuredModel);
+        if (sessionFamily && configFamily && sessionFamily === configFamily) {
+          return result; // same family, no pin needed
+        }
+        // Pin to the family alias (e.g., "opus") instead of the full JSONL model name
+        // (e.g., "claude-opus-4-6"). The Claude CLI rejects full model IDs via the API.
+        if (sessionFamily) {
+          return {
+            shouldResume: true,
+            modelPin: sessionFamily,
+            reason: '',
+          };
+        }
+        // Cannot determine session model family — don't pin, use configured model
+        return result;
       }
     } catch {
       return result;
@@ -640,31 +674,18 @@ function createClaudeEngine(deps) {
    * Auto-generate a session name using Haiku (async, non-blocking).
    * Writes to Claude's session file (unified with /rename).
    */
-  async function autoNameSession(chatId, sessionId, firstPrompt, cwd) {
+  function autoNameSession(_chatId, sessionId, firstPrompt, cwd, labelPrefix = '') {
     try {
-      const namePrompt = `Generate a very short session name (2-5 Chinese characters, no punctuation, no quotes) that captures the essence of this user request:
-
-"${firstPrompt.slice(0, 200)}"
-
-Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug修复, 代码审查`;
-
-      const { output } = await spawnClaudeAsync(
-        ['-p', '--model', 'haiku'],
-        namePrompt,
-        HOME,
-        15000 // 15s timeout
-      );
-
-      if (output) {
-        // Clean up: remove quotes, punctuation, trim
-        let name = output.replace(/["""''`]/g, '').replace(/[.,!?:;。，！？：；]/g, '').trim();
-        // Limit to reasonable length
-        if (name.length > 12) name = name.slice(0, 12);
-        if (name.length >= 2) {
-          // Write to Claude's session file (unified with /rename on desktop)
-          writeSessionName(sessionId, cwd, name);
-        }
-      }
+      // Use first user message as session name (same as desktop Claude Code behavior).
+      // No AI generation — instant, zero-cost, and more recognizable.
+      let name = String(firstPrompt || '').trim().split('\n')[0];
+      // Strip command prefixes
+      name = name.replace(/^\/\S+\s*/, '').trim();
+      // Truncate to reasonable display length
+      if (name.length > 60) name = name.slice(0, 57) + '...';
+      if (!name) return;
+      name = labelPrefix + name;
+      writeSessionName(sessionId, cwd, name);
     } catch (e) {
       log('DEBUG', `Auto-name failed for ${sessionId.slice(0, 8)}: ${e.message}`);
     }
@@ -763,6 +784,7 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
     metameSenderId = '',
     runtime = null,
     onSession = null,
+    options = {},
   ) {
     return new Promise((resolve) => {
       let settled = false;
@@ -772,17 +794,31 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
         resolve(payload);
       };
       const rt = runtime || getEngineRuntime(getDefaultEngine());
+      const { warmChild, persistent, warmPool: _warmPool, warmSessionKey } = options;
+      const isPersistent = persistent && rt.name === 'claude'; // Only Claude supports stream-json
       const streamArgs = rt.name === 'claude'
-        ? [...args, '--output-format', 'stream-json', '--verbose']
+        ? [...args, '--output-format', 'stream-json', '--verbose', ...(isPersistent ? ['--input-format', 'stream-json'] : [])]
         : args;
       const _spawnAt = Date.now();
-      const child = spawn(rt.binary, streamArgs, {
-        cwd,
-        stdio: ['pipe', 'pipe', 'pipe'],
-        detached: process.platform !== 'win32',
-        env: rt.buildEnv({ metameProject, metameSenderId }),
-      });
-      log('INFO', `[TIMING:${chatId}] spawned ${rt.name} pid=${child.pid}`);
+
+      let child;
+      if (warmChild) {
+        // Reuse warm process — remove stale listeners, attach fresh ones below
+        child = warmChild;
+        child.stdout.removeAllListeners('data');
+        child.stderr.removeAllListeners('data');
+        child.removeAllListeners('close');
+        child.removeAllListeners('error');
+        log('INFO', `[TIMING:${chatId}] reusing warm pid=${child.pid} (+0ms)`);
+      } else {
+        child = spawn(rt.binary, streamArgs, {
+          cwd,
+          stdio: ['pipe', 'pipe', 'pipe'],
+          detached: process.platform !== 'win32',
+          env: rt.buildEnv({ metameProject, metameSenderId }),
+        });
+        log('INFO', `[TIMING:${chatId}] spawned ${rt.name} pid=${child.pid}`);
+      }
 
       if (chatId) {
         activeProcesses.set(chatId, {
@@ -932,6 +968,27 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
                 _streamText = finalResult;
               }
               flushStream(true); // force final text flush before process ends
+
+              // Persistent mode: finalize on result event, keep process alive for reuse
+              if (isPersistent) {
+                clearTimeout(idleTimer);
+                clearTimeout(ceilingTimer);
+                clearTimeout(sigkillTimer);
+                clearInterval(milestoneTimer);
+                if (chatId) { activeProcesses.delete(chatId); saveActivePids(); }
+                // Store process back in warm pool for next turn
+                if (_warmPool && warmSessionKey && child && !child.killed && child.exitCode === null) {
+                  _warmPool.storeWarm(warmSessionKey, child, { sessionId: observedSessionId, cwd });
+                }
+                finalize({
+                  output: finalResult || '',
+                  error: null,
+                  files: writtenFiles,
+                  toolUsageLog,
+                  usage: finalUsage,
+                  sessionId: observedSessionId || '',
+                });
+              }
               continue;
             }
             if (event.type === 'tool_result') {
@@ -1018,6 +1075,10 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
         resetIdleTimer();
         const chunk = data.toString();
         stderr += chunk;
+        // Detect API errors (400, model not supported, etc.) and log them explicitly
+        if (/\b(400|is not supported|model.*not found|invalid.*model)\b/i.test(chunk)) {
+          log('ERROR', `[API-ERROR] ${rt.name} stderr for ${chatId}: ${chunk.slice(0, 300)}`);
+        }
         if (!classifiedError && typeof rt.classifyError === 'function') {
           classifiedError = rt.classifyError(chunk);
         }
@@ -1030,6 +1091,14 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
         clearTimeout(sigkillTimer);
         clearInterval(milestoneTimer);
 
+        // Persistent mode: if already finalized on result event, just clean up
+        if (isPersistent && settled) {
+          if (chatId) { activeProcesses.delete(chatId); saveActivePids(); }
+          // Process died after we returned result — remove from warm pool
+          if (_warmPool && warmSessionKey) _warmPool.releaseWarm(warmSessionKey);
+          return;
+        }
+
         if (buffer.trim()) {
           const events = parseEventsFromLine(buffer.trim());
           for (const event of events) {
@@ -1046,12 +1115,15 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
         if (chatId) { activeProcesses.delete(chatId); saveActivePids(); }
 
         if (wasAborted) {
+          const _errCode = (abortReason === 'daemon-restart' || abortReason === 'shutdown')
+            ? 'INTERRUPTED_RESTART'
+            : abortReason === 'merge-pause'
+              ? 'INTERRUPTED_MERGE_PAUSE'
+              : 'INTERRUPTED_USER';
           finalize({
             output: finalResult || null,
-            error: 'Stopped by user',
-            errorCode: (abortReason === 'daemon-restart' || abortReason === 'shutdown')
-              ? 'INTERRUPTED_RESTART'
-              : 'INTERRUPTED_USER',
+            error: abortReason === 'merge-pause' ? 'Paused for merge' : 'Stopped by user',
+            errorCode: _errCode,
             files: writtenFiles,
             toolUsageLog,
             usage: finalUsage,
@@ -1088,8 +1160,13 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
       });
 
       try {
-        child.stdin.write(input);
-        child.stdin.end();
+        if (isPersistent && _warmPool) {
+          // Stream-json mode: write JSON-formatted message, keep stdin open
+          child.stdin.write(_warmPool.buildStreamMessage(input, observedSessionId || ''));
+        } else {
+          child.stdin.write(input);
+          child.stdin.end();
+        }
       } catch (e) {
         clearTimeout(idleTimer);
         clearTimeout(ceilingTimer);
@@ -1157,6 +1234,24 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
   async function askClaude(bot, chatId, prompt, config, readOnly = false, senderId = null) {
     const _t0 = Date.now();
     log('INFO', `askClaude for ${chatId}: ${prompt.slice(0, 50)}`);
+
+    // Serialization is now guaranteed by daemon-message-pipeline (per-chatId Promise chain).
+    // No race guard needed here — pipeline ensures only one askClaude runs per chatId.
+    // Defense-in-depth: if a stale entry exists with a live child, kill it first.
+    const _existing = activeProcesses.get(chatId);
+    if (_existing && _existing.child && !_existing.aborted) {
+      log('WARN', `askClaude: overwriting active process for ${chatId} — aborting previous`);
+      try { process.kill(-_existing.child.pid, 'SIGTERM'); } catch { try { _existing.child.kill('SIGTERM'); } catch { /* */ } }
+    }
+    activeProcesses.set(chatId, {
+      child: null,       // sentinel: no process yet
+      aborted: false,
+      abortReason: null,
+      startedAt: _t0,
+      engine: 'pending',
+      killSignal: 'SIGTERM',
+    });
+
     // Track interaction time for idle/sleep detection
     if (touchInteraction) touchInteraction();
     // Track per-session last_active for summary generation (P2-B)
@@ -1181,13 +1276,33 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
     const _ackBoundKey = _ackAgentMap[_ackChatIdStr] || projectKeyFromVirtualChatId(_ackChatIdStr);
     const _ackBoundProj = _ackBoundKey && config.projects ? config.projects[_ackBoundKey] : null;
     // _ackCardHeader: non-null for agents with icon/name (team members, dispatch); passed to editMessage to preserve header on streaming edits
-    const _ackCardHeader = (_ackBoundProj && _ackBoundProj.icon && _ackBoundProj.name)
+    let _ackCardHeader = (_ackBoundProj && _ackBoundProj.icon && _ackBoundProj.name)
       ? { title: `${_ackBoundProj.icon} ${_ackBoundProj.name}`, color: _ackBoundProj.color || 'blue' }
       : null;
-    // Fire-and-forget: don't await Telegram RTT before spawning the engine process.
-    // statusMsgId will be populated well before the first model output (~5s for codex).
-    // For branded agents: send a card with header so streaming edits preserve the agent identity.
-    if (!bot.suppressAck) {
+    // Reuse card from a paused merge (same card, no new push)
+    const _pausedCard = _pausedCards.get(chatId);
+    if (_pausedCard) {
+      _pausedCards.delete(chatId);
+      // Discard stale paused cards (>30s old) — they may come from cancelled flushes
+      const cardAge = _pausedCard.savedAt ? Date.now() - _pausedCard.savedAt : 0;
+      if (cardAge > 30000) {
+        log('INFO', `[askClaude] Discarding stale paused card for ${chatId} (${Math.round(cardAge / 1000)}s old)`);
+        if (_pausedCard.statusMsgId && bot.deleteMessage) bot.deleteMessage(chatId, _pausedCard.statusMsgId).catch(() => {});
+      } else {
+        statusMsgId = _pausedCard.statusMsgId;
+        if (_pausedCard.cardHeader) _ackCardHeader = _pausedCard.cardHeader;
+        log('INFO', `[askClaude] Reusing paused card ${statusMsgId} for ${chatId}`);
+      }
+    }
+    if (_pausedCard && statusMsgId) {
+      // Update card to show "merging" state
+      if (statusMsgId && bot.editMessage) {
+        bot.editMessage(chatId, statusMsgId, '🔄 合并处理中…', _ackCardHeader).catch(() => {});
+      }
+    } else if (!bot.suppressAck) {
+      // Fire-and-forget: don't await Telegram RTT before spawning the engine process.
+      // statusMsgId will be populated well before the first model output (~5s for codex).
+      // For branded agents: send a card with header so streaming edits preserve the agent identity.
       const _ackFn = (_ackCardHeader && bot.sendCard)
         ? () => bot.sendCard(chatId, { title: _ackCardHeader.title, body: '🤔', color: _ackCardHeader.color })
         : () => (bot.sendMarkdown ? bot.sendMarkdown(chatId, '🤔') : bot.sendMessage(chatId, '🤔'));
@@ -1222,6 +1337,9 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
         if (!rest) {
           // Pure nickname call — confirm switch and stop
           clearInterval(typingTimer);
+          // Clean up pending sentinel (no spawn will follow)
+          const _ps = activeProcesses.get(chatId);
+          if (_ps && _ps.child === null) { activeProcesses.delete(chatId); saveActivePids(); }
           await bot.sendMessage(chatId, `${proj.icon || '🤖'} ${proj.name || key} 在线`);
           return { ok: true };
         }
@@ -1289,6 +1407,11 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
       session.engine = engineName; // keep local copy for Codex resume detection below
       session.logicalChatId = sessionChatId;
 
+      // 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;
+      const _warmEntry = (warmPool && runtime.name === 'claude') ? warmPool.acquireWarm(_warmSessionKey) : null;
+
       // Pre-spawn session validation: unified for all engines.
       // Claude checks JSONL file existence; Codex checks SQLite. Same interface, different backend.
       // Skip warning for virtual agents (team members) - they may use worktrees with fresh sessions
@@ -1364,8 +1487,9 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
       // When resuming a Claude session, inspect the original model first.
       // Thinking block signatures are model-specific; non-Claude JSONL sessions
       // must not be resumed as Claude.
-      if (runtime.name === 'claude' && session.started && session.id) {
-        const resumeInspection = inspectClaudeResumeSession(session);
+      // Skip for warm process reuse — model is already loaded in the persistent process.
+      if (runtime.name === 'claude' && session.started && session.id && !_warmEntry) {
+        const resumeInspection = inspectClaudeResumeSession(session, model);
         if (resumeInspection.shouldResume === false) {
           log('INFO', `[ModelPin] session ${session.id.slice(0, 8)} flagged as ${resumeInspection.reason}; starting fresh Claude session`);
           session = createSession(sessionChatId, session.cwd, boundProject && boundProject.name ? boundProject.name : '', runtime.name);
@@ -1636,7 +1760,12 @@ ${mentorRadarHint}
           log('WARN', `Intent registry injection failed: ${e.message}`);
         }
       }
-      const fullPrompt = routedPrompt + daemonHint + intentHint + agentHint + macAutomationHint + summaryHint + memoryHint + mentorHint + langGuard;
+      // For warm process reuse: context is already in the persistent process,
+      // so only send the user's actual prompt — skip all hint injection.
+      // This saves ~500-1500 tokens per turn and avoids context duplication.
+      const fullPrompt = _warmEntry
+        ? routedPrompt
+        : routedPrompt + daemonHint + intentHint + agentHint + macAutomationHint + summaryHint + memoryHint + mentorHint + langGuard;
       if (runtime.name === 'codex' && session.started && session.id && requestedCodexPermissionProfile) {
         const actualPermissionProfile = getActualCodexPermissionProfile(session);
         if (codexNeedsFallbackForRequestedPermissions(actualPermissionProfile, requestedCodexPermissionProfile)) {
@@ -1654,6 +1783,7 @@ ${mentorRadarHint}
         daemonCfg,
         session,
         cwd: session.cwd,
+        addDirs: boundProject && boundProject.addDirs,
         permissionProfile: runtime.name === 'codex' ? requestedCodexPermissionProfile : null,
       });
 
@@ -1683,7 +1813,7 @@ ${mentorRadarHint}
       // Skip for virtual agents (team clones like _agent_yi) — each has its own worktree,
       // but checkpoint uses `git add -A` which could interfere with parallel work.
       const _isVirtualAgent = String(chatId).startsWith('_agent_') || String(chatId).startsWith('_scope_');
-      if (!_isVirtualAgent) {
+      if (!_isVirtualAgent && !_warmEntry) {
         try {
           // Do NOT pass prompt — conversation content must never enter git history
           const checkpointResult = (gitCheckpointAsync || gitCheckpoint)(session.cwd);
@@ -1778,6 +1908,28 @@ ${mentorRadarHint}
         }
       };
 
+      // Check if user cancelled during pre-spawn phase (sentinel was marked aborted)
+      // Stamp session ID on card header so user can track session continuity
+      if (session && session.id && _ackCardHeader) {
+        _ackCardHeader = { ..._ackCardHeader, title: `${_ackCardHeader.title}（${session.id.slice(0, 8)}）` };
+      }
+
+      const _preSentinel = activeProcesses.get(chatId);
+      if (_preSentinel && _preSentinel.child === null && _preSentinel.aborted) {
+        clearInterval(typingTimer);
+        const _preReason = _preSentinel.abortReason || '';
+        activeProcesses.delete(chatId); saveActivePids();
+        if (_preReason === 'merge-pause' && statusMsgId) {
+          // Save card for reuse by the merged flush
+          _pausedCards.set(chatId, { statusMsgId, cardHeader: _ackCardHeader, savedAt: Date.now() });
+          if (bot.editMessage) bot.editMessage(chatId, statusMsgId, '⏸ 合并中…', _ackCardHeader).catch(() => {});
+        } else if (statusMsgId && bot.deleteMessage) {
+          bot.deleteMessage(chatId, statusMsgId).catch(() => {});
+        }
+        log('INFO', `[askClaude] Pre-spawn abort for ${chatId}: ${_preReason || 'user cancelled'}`);
+        return { ok: false, error: _preReason === 'merge-pause' ? 'Paused for merge' : 'Stopped by user' };
+      }
+
       let output, error, errorCode, files, toolUsageLog, timedOut, sessionId;
       try {
         ({
@@ -1799,6 +1951,12 @@ ${mentorRadarHint}
           normalizeSenderId(senderId),
           runtime,
           onSession,
+          {
+            warmChild: _warmEntry ? _warmEntry.child : null,
+            persistent: runtime.name === 'claude' && !!warmPool,
+            warmPool,
+            warmSessionKey: _warmSessionKey,
+          },
         ));
 
         if (sessionId) await onSession(sessionId);
@@ -1936,6 +2094,9 @@ ${mentorRadarHint}
         }
       } catch (spawnErr) {
         clearInterval(typingTimer);
+        // Clean up pending sentinel if spawn never completed
+        const _ps2 = activeProcesses.get(chatId);
+        if (_ps2 && _ps2.child === null) { activeProcesses.delete(chatId); saveActivePids(); }
         if (statusMsgId && bot.deleteMessage) bot.deleteMessage(chatId, statusMsgId).catch(() => { });
         log('ERROR', `spawnClaudeStreaming crashed for ${chatId}: ${spawnErr.message}`);
         await bot.sendMessage(chatId, `❌ 内部错误: ${spawnErr.message}`).catch(() => { });
@@ -2105,8 +2266,9 @@ ${mentorRadarHint}
           if (!replyMsg) {
             if (activeProject && bot.sendCard) {
               log('DEBUG', `[REPLY:${chatId}] sending sendCard`);
+              const _sessionTag = session && session.id ? `（${session.id.slice(0, 8)}）` : '';
               replyMsg = await bot.sendCard(chatId, {
-                title: `${activeProject.icon || '🤖'} ${activeProject.name || ''}`,
+                title: `${activeProject.icon || '🤖'} ${activeProject.name || ''}${_sessionTag}`,
                 body: cleanOutput,
                 color: activeProject.color || 'blue',
               });
@@ -2149,9 +2311,13 @@ ${mentorRadarHint}
           try { await bot.sendMessage(chatId, error); } catch { /* */ }
         }
 
-        // Auto-name: if this was the first message and session has no name, generate one
+        // Auto-name: if this was the first message and session has no name, generate one.
+        // Add agent label prefix so desktop users can identify which agent owns the session.
         if (runtime.name === 'claude' && wasNew && !getSessionName(session.id)) {
-          autoNameSession(chatId, session.id, prompt, session.cwd).catch(() => { });
+          const _agentLabel = (boundProject && boundProject.name)
+            ? `[${boundProject.name}] `
+            : (projectKey ? `[${projectKey}] ` : '');
+          autoNameSession(chatId, session.id, prompt, session.cwd, _agentLabel).catch(() => { });
         }
 
         // Auto-refresh memory-snapshot.md for this agent on first session message (fire-and-forget)
@@ -2180,6 +2346,17 @@ ${mentorRadarHint}
           : `Error: ${errMsg.slice(0, 200)}`;
         log('ERROR', `ask${runtime.name === 'codex' ? 'Codex' : 'Claude'} failed for ${chatId}: ${errMsg.slice(0, 300)} (${errorCode || 'NO_CODE'})`);
 
+        // Merge-pause: save card for reuse, don't show error to user
+        if (errorCode === 'INTERRUPTED_MERGE_PAUSE') {
+          if (statusMsgId) {
+            _pausedCards.set(chatId, { statusMsgId, cardHeader: _ackCardHeader, savedAt: Date.now() });
+            // Update card to show paused state
+            if (bot.editMessage) bot.editMessage(chatId, statusMsgId, '⏸ 合并中…', _ackCardHeader).catch(() => {});
+            log('INFO', `[askClaude] Saved paused card ${statusMsgId} for ${chatId}`);
+          }
+          return { ok: false, error: errMsg, errorCode };
+        }
+
         // If session not found / locked / thinking signature invalid — create new and retry once (Claude path)
         const _isThinkingSignatureError = isClaudeThinkingSignatureError(errMsg);
         const _isSessionResumeFail = errMsg.includes('not found') || errMsg.includes('No session') || errMsg.includes('already in use') || _isThinkingSignatureError;
@@ -2227,8 +2404,8 @@ ${mentorRadarHint}
           // Auto-fallback: if custom provider/model fails, revert to anthropic + opus (Claude path only)
           if (runtime.name === 'claude') {
             const activeProv = providerMod ? providerMod.getActiveName() : 'anthropic';
-            const builtinModels = ENGINE_MODEL_CONFIG.claude.options;
-            if ((activeProv !== 'anthropic' || !builtinModels.includes(model)) && !errMsg.includes('Stopped by user')) {
+            const builtinModelValues = (ENGINE_MODEL_CONFIG.claude.options || []).map(o => typeof o === 'string' ? o : o.value);
+            if ((activeProv !== 'anthropic' || !builtinModelValues.includes(model)) && !errMsg.includes('Stopped by user')) {
               try {
                 config = fallbackToDefaultProvider(`${activeProv}/${model} error: ${errMsg.slice(0, 100)}`);
                 await bot.sendMessage(chatId, `⚠️ ${activeProv}/${model} 失败，已回退到 anthropic/opus\n原因: ${errMsg.slice(0, 100)}`);
@@ -2248,6 +2425,9 @@ ${mentorRadarHint}
 
     } catch (fatalErr) { // ── safety-net-catch ──
       clearInterval(typingTimer);
+      // Clean up pending sentinel if spawn never completed
+      const _ps3 = activeProcesses.get(chatId);
+      if (_ps3 && _ps3.child === null) { activeProcesses.delete(chatId); saveActivePids(); }
       if (statusMsgId && bot.deleteMessage) await bot.deleteMessage(chatId, statusMsgId).catch(() => { });
       log('FATAL', `[askClaude] Uncaught error for ${chatId}: ${fatalErr.message}\n${fatalErr.stack}`);
       try { await bot.sendMessage(chatId, `❌ 内部错误: ${fatalErr.message}`); } catch { /* */ }

package/scripts/daemon-command-router.js

@@ -19,7 +19,7 @@ function createCommandRouter(deps) {
     providerMod,
     getNoSleepProcess,
     activeProcesses,
-    messageQueue,
+    pipeline,      // message pipeline — used for interrupt/clearQueue
     log,
     agentTools,
     pendingAgentFlows,
@@ -28,70 +28,7 @@ function createCommandRouter(deps) {
     getDefaultEngine,
   } = deps;
 
-  function clearQueuedTimer(chatId) {
-    const q = messageQueue && messageQueue.get(chatId);
-    if (q && q.timer) {
-      clearTimeout(q.timer);
-      q.timer = null;
-    }
-  }
-
-  function interruptActiveProcess(chatId) {
-    const proc = activeProcesses.get(chatId);
-    if (proc && proc.child) {
-      proc.aborted = true;
-      const signal = proc.killSignal || 'SIGTERM';
-      try { process.kill(-proc.child.pid, signal); } catch { try { proc.child.kill(signal); } catch { /* */ } }
-      return true;
-    }
-    return false;
-  }
 
-  function shouldPauseAndMergeFollowUps(chatId) {
-    const proc = activeProcesses.get(chatId);
-    return !!(proc && proc.engine === 'codex');
-  }
-
-  function getFollowUpDebounceMs(config) {
-    const raw = Number(config && config.daemon && config.daemon.follow_up_debounce_ms);
-    if (Number.isFinite(raw) && raw >= 300) return raw;
-    return 2500;
-  }
-
-  function buildMergedFollowUpPrompt(messages) {
-    return [
-      '继续上面的工作，并结合我刚刚连续补充的消息统一处理：',
-      '',
-      messages.join('\n'),
-    ].join('\n');
-  }
-
-  function scheduleQueuedResume(bot, chatId, config, readOnly, senderId) {
-    const q = messageQueue.get(chatId);
-    if (!q || q.mode !== 'resume-after-pause') return;
-    clearQueuedTimer(chatId);
-    const delay = getFollowUpDebounceMs(config);
-    q.timer = setTimeout(async () => {
-      const pending = messageQueue.get(chatId);
-      if (!pending || pending.mode !== 'resume-after-pause') return;
-      if (activeProcesses.has(chatId)) {
-        scheduleQueuedResume(bot, chatId, config, readOnly, senderId);
-        return;
-      }
-      const msgs = pending.messages.splice(0);
-      messageQueue.delete(chatId);
-      if (msgs.length === 0) return;
-      log('INFO', `Follow-up: resuming with ${msgs.length} merged queued message(s) for ${chatId}`);
-      resetCooldown(chatId);
-      try {
-        await askClaude(bot, chatId, buildMergedFollowUpPrompt(msgs), config, readOnly, senderId);
-      } catch (err) {
-        log('WARN', `Follow-up resume failed for ${chatId}: ${err.message}`);
-        try { await bot.sendMessage(chatId, `⚠️ 继续处理补充消息失败：${err.message}`); } catch { /* */ }
-      }
-    }, delay);
-    if (typeof q.timer.unref === 'function') q.timer.unref();
-  }
 
   function resolveFlowTtlMs() {
     const raw = typeof agentFlowTtlMs === 'function' ? agentFlowTtlMs() : agentFlowTtlMs;
@@ -755,11 +692,11 @@ function createCommandRouter(deps) {
     const INTERRUPT_RE = /^(等一下|等等|等下|停一下|停下|停|先停|hold\s*on|wait|暂停)$/i;
     if (activeProcesses.has(chatId) && INTERRUPT_RE.test(text.trim())) {
       // Kill current process but preserve session for resume
-      if (messageQueue.has(chatId)) {
-        clearQueuedTimer(chatId);
-        messageQueue.delete(chatId);
+      const _pl = pipeline && pipeline.current;
+      if (_pl) {
+        _pl.clearQueue(chatId);
+        _pl.interruptActive(chatId);
       }
-      interruptActiveProcess(chatId);
       await bot.sendMessage(chatId, '⏸ 好的，听你说');
       return;
     }
@@ -778,47 +715,6 @@ function createCommandRouter(deps) {
       // No session found — fall through to normal askClaude
     }
 
-    // While collecting follow-up messages after a pause, keep merging them until the debounce window closes.
-    if (messageQueue.has(chatId)) {
-      const q = messageQueue.get(chatId);
-      if (q && q.mode === 'resume-after-pause') {
-        q.messages.push(text);
-        scheduleQueuedResume(bot, chatId, config, readOnly, senderId);
-        return;
-      }
-    }
-
-    // If a task is running: pause it, collect the user's burst of messages, then resume with a merged follow-up.
-    if (activeProcesses.has(chatId)) {
-      if (!shouldPauseAndMergeFollowUps(chatId)) {
-        const isFirst = !messageQueue.has(chatId);
-        if (isFirst) {
-          messageQueue.set(chatId, { messages: [] });
-        }
-        const q = messageQueue.get(chatId);
-        if (q.messages.length >= 10) {
-          await bot.sendMessage(chatId, '⚠️ 排队已满（10条），请等当前任务完成');
-          return;
-        }
-        q.messages.push(text);
-        if (isFirst) {
-          await bot.sendMessage(chatId, '📝 收到，完成后继续处理');
-        }
-        return;
-      }
-      const isFirst = !messageQueue.has(chatId);
-      if (isFirst) {
-        messageQueue.set(chatId, { messages: [], mode: 'resume-after-pause', timer: null });
-      }
-      const q = messageQueue.get(chatId);
-      q.messages.push(text);
-      if (isFirst) {
-        interruptActiveProcess(chatId);
-        await bot.sendMessage(chatId, '⏸ 已暂停当前任务，你可以继续连发，我会自动合并后续内容再继续');
-      }
-      scheduleQueuedResume(bot, chatId, config, readOnly, senderId);
-      return;
-    }
     // Strict mode: chats with a fixed agent in chat_agent_map must not cross-dispatch
     const _strictChatAgentMap = {
       ...(config.telegram ? config.telegram.chat_agent_map : {}),
@@ -874,22 +770,7 @@ function createCommandRouter(deps) {
         log('WARN', `Claude-first mac fallback handled for ${String(chatId).slice(-8)} (mode=${macControlMode})`);
       }
     }
-
-    // Process queued messages as follow-up in the same session (no kill, no context loss)
-    // Use while-loop instead of recursion to avoid unbounded stack growth
-    while (messageQueue.has(chatId)) {
-      const q = messageQueue.get(chatId);
-      if (q && q.mode === 'resume-after-pause') break;
-      const msgs = q.messages.splice(0);
-      messageQueue.delete(chatId);
-      if (msgs.length === 0) break;
-      const combined = msgs.join('\n');
-      log('INFO', `Follow-up: processing ${msgs.length} queued message(s) for ${chatId}`);
-      resetCooldown(chatId);
-      const followUp = await askClaude(bot, chatId, combined, config, readOnly, senderId);
-      if (followUp && followUp.error === 'Stopped by user') break;
-    }
-
+    return claudeResult;
   }
 
   return { handleCommand };