metame-cli 1.4.34 → 1.5.1

package/scripts/daemon-claude-engine.js

@@ -1,6 +1,9 @@
 'use strict';
 
 const { classifyChatUsage } = require('./usage-classifier');
+const { deriveProjectInfo } = require('./utils');
+const { createEngineRuntimeFactory, normalizeEngineName, ENGINE_MODEL_CONFIG } = require('./daemon-engine-runtime');
+const { buildAgentContextForEngine, buildMemorySnapshotContent, refreshMemorySnapshot } = require('./agent-layer');
 
 function createClaudeEngine(deps) {
   const {
@@ -30,93 +33,158 @@ function createClaudeEngine(deps) {
     findSessionFile,
     listRecentSessions,
     getSession,
+    getSessionForEngine,
     createSession,
     getSessionName,
     writeSessionName,
     markSessionStarted,
+    isEngineSessionValid,
     gitCheckpoint,
+    gitCheckpointAsync,
     recordTokens,
     skillEvolution,
     touchInteraction,
     statusThrottleMs = 3000,
     fallbackThrottleMs = 8000,
+    getEngineRuntime: injectedGetEngineRuntime,
+    getDefaultEngine: _getDefaultEngine,
   } = deps;
+  function getDefaultEngine() {
+    return (typeof _getDefaultEngine === 'function') ? _getDefaultEngine() : 'claude';
+  }
+  let mentorEngine = null;
+  try { mentorEngine = require('./mentor-engine'); } catch { /* optional */ }
+  let sessionAnalytics = null;
+  try { sessionAnalytics = require('./session-analytics'); } catch { /* optional */ }
+
+  const getEngineRuntime = typeof injectedGetEngineRuntime === 'function'
+    ? injectedGetEngineRuntime
+    : createEngineRuntimeFactory({ fs, path, HOME, CLAUDE_BIN, getActiveProviderEnv });
+
+  // On Windows, spawning .cmd files via shell:true causes cmd.exe to flash briefly.
+  // Instead, read the .cmd wrapper, extract the real Node.js entry point, and spawn
+  // `node <entry.js> <args>` directly — completely bypasses cmd.exe, zero flash.
+  function resolveNodeEntry(cmdPath) {
+    try {
+      const content = fs.readFileSync(cmdPath, 'utf8');
+      // Match the quoted .js path just before %* at end of last exec line
+      const m = content.match(/"([^"]+\.js)"\s*%\*\s*$/m);
+      if (m) {
+        // Substitute %dp0% (batch var for the cmd file's own directory)
+        const entry = m[1].replace(/%dp0%/gi, path.dirname(cmdPath) + path.sep);
+        if (fs.existsSync(entry)) return entry;
+      }
+    } catch { /* ignore */ }
+    return null;
+  }
 
-  // On Windows, .cmd files need shell to spawn; use COMSPEC to avoid conda PATH issues
-  function spawn(cmd, args, options) {
-    if (process.platform === 'win32' && cmd === CLAUDE_BIN) {
-      return _spawn(cmd, args, { ...options, shell: process.env.COMSPEC || true });
+  // Cache resolved entries so we only read .cmd files once
+  const _nodeEntryCache = new Map();
+  function resolveNodeEntryForCmd(cmd) {
+    if (_nodeEntryCache.has(cmd)) return _nodeEntryCache.get(cmd);
+    let cmdPath = cmd;
+    const lowerCmd = String(cmd || '').toLowerCase();
+    // If bare name (not a file path), find the .cmd via where
+    if (lowerCmd === 'claude' || lowerCmd === 'codex') {
+      try {
+        const { execSync: _es } = require('child_process');
+        const lines = _es(`where ${cmd}`, { encoding: 'utf8', timeout: 3000 })
+          .split('\n').map(l => l.trim()).filter(Boolean);
+        cmdPath = lines.find(l => l.toLowerCase().endsWith(`${lowerCmd}.cmd`)) || lines[0] || cmd;
+      } catch { /* ignore */ }
     }
-    return _spawn(cmd, args, options);
+    const entry = resolveNodeEntry(cmdPath);
+    _nodeEntryCache.set(cmd, entry);
+    return entry;
   }
 
-  const SESSION_CWD_VALIDATION_TTL_MS = 30 * 1000;
-  const _sessionCwdValidationCache = new Map(); // key: `${sessionId}@@${cwd}` -> { inCwd, ts }
+  function spawn(cmd, args, options) {
+    if (process.platform !== 'win32') return _spawn(cmd, args, options);
 
-  function cacheSessionCwdValidation(cacheKey, inCwd) {
-    _sessionCwdValidationCache.set(cacheKey, { inCwd: !!inCwd, ts: Date.now() });
-    if (_sessionCwdValidationCache.size > 512) {
-      const firstKey = _sessionCwdValidationCache.keys().next().value;
-      if (firstKey) _sessionCwdValidationCache.delete(firstKey);
+    const lowerCmd = String(cmd || '').toLowerCase();
+    const isCmdLike = lowerCmd.endsWith('.cmd') || lowerCmd.endsWith('.bat')
+      || cmd === CLAUDE_BIN || lowerCmd === 'claude' || lowerCmd === 'codex';
+
+    if (isCmdLike) {
+      const entry = resolveNodeEntryForCmd(cmd);
+      if (entry) {
+        // Run node directly — no cmd.exe, no flash
+        return _spawn(process.execPath, [entry, ...args], { ...options, windowsHide: true });
+      }
+      // Fallback: shell with windowsHide
+      return _spawn(cmd, args, { ...options, shell: process.env.COMSPEC || true, windowsHide: true });
     }
-    return !!inCwd;
+    return _spawn(cmd, args, { ...options, windowsHide: true });
   }
 
-  function isSessionInCwd(sessionId, cwd) {
-    const safeSessionId = String(sessionId || '').trim();
-    if (!safeSessionId || !cwd) return false;
+  // Per-chatId patch queues: Agent A's writes never block Agent B.
+  const _patchQueues = new Map(); // chatId -> Promise
+  function patchSessionSerialized(chatId, patchFn) {
+    const prev = _patchQueues.get(chatId) || Promise.resolve();
+    const next = prev.then(() => {
+      const state = loadState();
+      if (!state.sessions) state.sessions = {};
+      const cur = state.sessions[chatId] || {};
+      const patched = typeof patchFn === 'function' ? patchFn(cur) : cur;
+      state.sessions[chatId] = patched && typeof patched === 'object' ? patched : cur;
+      saveState(state);
+    }).catch((e) => {
+      log('WARN', `patchSessionSerialized failed for ${chatId}: ${e.message}`);
+    });
+    _patchQueues.set(chatId, next);
+    // GC: remove resolved entries to prevent unbounded Map growth
+    next.then(() => { if (_patchQueues.get(chatId) === next) _patchQueues.delete(chatId); });
+    return next;
+  }
 
-    const normCwd = normalizeCwd(cwd);
-    const cacheKey = `${safeSessionId}@@${normCwd}`;
-    const cached = _sessionCwdValidationCache.get(cacheKey);
-    if (cached && (Date.now() - cached.ts) < SESSION_CWD_VALIDATION_TTL_MS) {
-      return !!cached.inCwd;
-    }
+  const CODEX_RESUME_RETRY_WINDOW_MS = 10 * 60 * 1000;
+  const _codexResumeRetryTs = new Map(); // chatId -> last retry ts
 
-    try {
-      // Fast path: locate the exact session file, then validate its indexed projectPath.
-      if (typeof findSessionFile === 'function') {
-        const sessionFile = findSessionFile(safeSessionId);
-        if (!sessionFile) return cacheSessionCwdValidation(cacheKey, false);
-
-        const projectDir = path.dirname(sessionFile);
-        const indexFile = path.join(projectDir, 'sessions-index.json');
-        if (fs.existsSync(indexFile)) {
-          const data = JSON.parse(fs.readFileSync(indexFile, 'utf8'));
-          const entries = Array.isArray(data && data.entries) ? data.entries : [];
-          const entry = entries.find(e => e && e.sessionId === safeSessionId);
-          if (entry && entry.projectPath) {
-            return cacheSessionCwdValidation(cacheKey, normalizeCwd(entry.projectPath) === normCwd);
-          }
-          // sessions-index may lag behind new sessions; use project-level path from any entry.
-          const anyProjectPath = (entries.find(e => e && e.projectPath) || {}).projectPath;
-          if (anyProjectPath) {
-            return cacheSessionCwdValidation(cacheKey, normalizeCwd(anyProjectPath) === normCwd);
-          }
-        }
+  function canRetryCodexResume(chatId) {
+    const key = String(chatId || '');
+    if (!key) return false;
+    const last = Number(_codexResumeRetryTs.get(key) || 0);
+    if (!last) return true;
+    return (Date.now() - last) > CODEX_RESUME_RETRY_WINDOW_MS;
+  }
 
-        // Weak fallback: encode normCwd using Claude's folder convention and accept
-        // only positive match. If it doesn't match, keep current session to avoid
-        // false mismatches for paths with non-ASCII/special characters.
-        const expectedDirName = '-' + normCwd.replace(/^\//, '').replace(/[\/_ ]/g, '-');
-        const actualDirName = path.basename(projectDir);
-        if (actualDirName === expectedDirName) {
-          return cacheSessionCwdValidation(cacheKey, true);
-        }
-        // Unable to prove mismatch safely.
-        return cacheSessionCwdValidation(cacheKey, true);
-      }
+  function markCodexResumeRetried(chatId) {
+    const key = String(chatId || '');
+    if (!key) return;
+    _codexResumeRetryTs.set(key, Date.now());
+  }
 
-      // Ultimate fallback (legacy path): scoped scan in target cwd.
-      const recentInCwd = listRecentSessions(1000, normCwd);
-      const existsInCwd = recentInCwd.some(s => s.sessionId === safeSessionId);
-      return cacheSessionCwdValidation(cacheKey, existsInCwd);
-    } catch {
-      // Conservative fallback: if validation infra fails, avoid false negatives by preserving current session.
-      return cacheSessionCwdValidation(cacheKey, true);
+  function shouldRetryCodexResumeFallback({ runtimeName, wasResumeAttempt, output, error, errorCode, canRetry }) {
+    return runtimeName === 'codex'
+      && !!wasResumeAttempt
+      && !!error
+      && (!output || !!errorCode)
+      && !!canRetry;
+  }
+
+  function formatEngineSpawnError(err, runtime) {
+    if (!err) return 'Unknown spawn error';
+    const rt = runtime || { name: getDefaultEngine() };
+    if (err.code === 'ENOENT') {
+      if (rt.name === 'codex') {
+        return 'Codex CLI 未安装。请先运行: npm install -g @openai/codex';
+      }
+      return 'Claude CLI 未安装或不在 PATH。请先确认 `claude` 可执行。';
     }
+    return err.message || String(err);
   }
 
+  function adaptDaemonHintForEngine(daemonHint, engineName) {
+    if (normalizeEngineName(engineName) === 'claude') return daemonHint;
+    let out = String(daemonHint || '');
+    // Keep this replacement conservative: only unwrap the known outer wrapper.
+    out = out.replace('[System hints - DO NOT mention these to user:', 'System hints (internal, do not mention to user):');
+    // The current daemonHint template ends with a single trailing `]`.
+    out = out.replace(/\]\s*$/, '');
+    return out;
+  }
+
+
   /**
    * Parse [[FILE:...]] markers from Claude output.
    * Returns { markedFiles, cleanOutput }
@@ -192,6 +260,82 @@ function createClaudeEngine(deps) {
     return null;
   }
 
+  function resolveMentorMode(cfg = {}) {
+    const mode = String(cfg.mode || '').trim().toLowerCase();
+    if (mode === 'gentle' || mode === 'active' || mode === 'intense') return mode;
+    const level = Number(cfg.friction_level);
+    if (Number.isFinite(level)) {
+      if (level >= 8) return 'intense';
+      if (level >= 4) return 'active';
+    }
+    return 'gentle';
+  }
+
+  function extractUserText(content) {
+    if (typeof content === 'string') return content;
+    if (!Array.isArray(content)) return '';
+    for (const item of content) {
+      if (item && item.type === 'text' && item.text) return item.text;
+    }
+    return '';
+  }
+
+  function collectRecentSessionSignals(sessionId, limit = 6) {
+    const out = { recentMessages: [], sessionStartTime: null };
+    if (!sessionId || typeof findSessionFile !== 'function') return out;
+    const file = findSessionFile(sessionId);
+    if (!file || !fs.existsSync(file)) return out;
+
+    try {
+      const raw = fs.readFileSync(file, 'utf8');
+      const lines = raw.split('\n').filter(Boolean).slice(-800);
+      let current = null;
+      for (const line of lines) {
+        let entry;
+        try { entry = JSON.parse(line); } catch { continue; }
+        if (!out.sessionStartTime && entry.timestamp) out.sessionStartTime = entry.timestamp;
+
+        if (entry.type === 'user' && entry.message) {
+          if (current) out.recentMessages.push(current);
+          current = {
+            text: extractUserText(entry.message.content),
+            tool_calls: 0,
+          };
+        } else if (entry.type === 'assistant' && current && entry.message && Array.isArray(entry.message.content)) {
+          for (const item of entry.message.content) {
+            if (item && item.type === 'tool_use') current.tool_calls++;
+          }
+        }
+      }
+      if (current) out.recentMessages.push(current);
+      if (out.recentMessages.length > limit) {
+        out.recentMessages = out.recentMessages.slice(-limit);
+      }
+    } catch {
+      return out;
+    }
+    return out;
+  }
+
+  function countCodeLines(output) {
+    const text = String(output || '');
+    if (!text.trim()) return 0;
+    const lines = text.split('\n');
+    let inFence = false;
+    let count = 0;
+    let sawFence = false;
+    for (const line of lines) {
+      if (/^\s*```/.test(line)) {
+        sawFence = true;
+        inFence = !inFence;
+        continue;
+      }
+      if (inFence && line.trim()) count++;
+    }
+    if (!sawFence) return 0;
+    return count;
+  }
+
   function isMacAutomationIntent(prompt) {
     const text = String(prompt || '').trim();
     if (!text) return false;
@@ -243,21 +387,24 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
   }
 
   /**
-   * Spawn claude as async child process (non-blocking).
+   * Spawn Claude as async child process (non-blocking).
+   * Intentionally Claude-only: used by naming/fallback helper paths that
+   * should not depend on project runtime adapter selection.
    * Returns { output, error } after process exits.
    */
   function spawnClaudeAsync(args, input, cwd, timeoutMs = 300000, metameProject = '') {
     return new Promise((resolve) => {
+      const env = {
+        ...process.env,
+        ...getActiveProviderEnv(),
+        METAME_INTERNAL_PROMPT: '1',
+        METAME_PROJECT: metameProject || '',
+      };
+      delete env.CLAUDECODE;
       const child = spawn(CLAUDE_BIN, args, {
         cwd,
         stdio: ['pipe', 'pipe', 'pipe'],
-        env: {
-          ...process.env,
-          ...getActiveProviderEnv(),
-          CLAUDECODE: undefined,
-          METAME_INTERNAL_PROMPT: '1',
-          METAME_PROJECT: metameProject || ''
-        },
+        env,
       });
 
       let stdout = '';
@@ -288,7 +435,7 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
 
       child.on('error', (err) => {
         clearTimeout(timer);
-        resolve({ output: null, error: err.message });
+        resolve({ output: null, error: formatEngineSpawnError(err, { name: getDefaultEngine() }) });
       });
 
       // Write input and close stdin
@@ -317,55 +464,80 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
   };
 
   /**
-   * Spawn claude with streaming output (stream-json mode).
-   * Calls onStatus callback when tool usage is detected.
-   * Returns { output, error } after process exits.
+   * Spawn engine with streaming output. Parser comes from runtime adapter.
+   * Returns { output, error, files, toolUsageLog, usage, sessionId }.
    */
-  function spawnClaudeStreaming(args, input, cwd, onStatus, timeoutMs = 600000, chatId = null, metameProject = '') {
+  function spawnClaudeStreaming(
+    args,
+    input,
+    cwd,
+    onStatus,
+    timeoutMs = 600000,
+    chatId = null,
+    metameProject = '',
+    runtime = null,
+    onSession = null,
+  ) {
     return new Promise((resolve) => {
-      // Add stream-json output format (requires --verbose)
-      const streamArgs = [...args, '--output-format', 'stream-json', '--verbose'];
-
-      const child = spawn(CLAUDE_BIN, streamArgs, {
+      let settled = false;
+      const finalize = (payload) => {
+        if (settled) return;
+        settled = true;
+        resolve(payload);
+      };
+      const rt = runtime || getEngineRuntime(getDefaultEngine());
+      const streamArgs = rt.name === 'claude'
+        ? [...args, '--output-format', 'stream-json', '--verbose']
+        : args;
+      const _spawnAt = Date.now();
+      const child = spawn(rt.binary, streamArgs, {
         cwd,
         stdio: ['pipe', 'pipe', 'pipe'],
-        detached: process.platform !== 'win32', // process groups are POSIX-only
-        env: {
-          ...process.env,
-          ...getActiveProviderEnv(),
-          CLAUDECODE: undefined,
-          METAME_PROJECT: metameProject || ''
-        },
+        detached: process.platform !== 'win32',
+        env: rt.buildEnv({ metameProject }),
       });
+      log('INFO', `[TIMING:${chatId}] spawned ${rt.name} pid=${child.pid}`);
 
-      // Track active process for /stop
       if (chatId) {
-        activeProcesses.set(chatId, { child, aborted: false, startedAt: Date.now() });
-        saveActivePids(); // Fix3: persist PID to disk
+        activeProcesses.set(chatId, {
+          child,
+          aborted: false,
+          startedAt: _spawnAt,
+          engine: rt.name,
+          killSignal: rt.killSignal || 'SIGTERM',
+        });
+        saveActivePids();
       }
 
       let buffer = '';
       let stderr = '';
       let killed = false;
-      let killedReason = 'idle'; // 'idle' | 'ceiling'
+      let killedReason = 'idle';
       let finalResult = '';
+      let finalUsage = null;
+      let observedSessionId = '';
+      let _firstOutputLogged = false;
+      let classifiedError = null;
       let lastStatusTime = 0;
       const STATUS_THROTTLE = statusThrottleMs;
-      const writtenFiles = []; // Track files created/modified by Write tool
-      const toolUsageLog = []; // Track all tool invocations for skill evolution
+      const writtenFiles = [];
+      const toolUsageLog = [];
 
-      // ── 自适应超时：5min 无输出判卡死 + 1h 绝对上限 ──
-      const IDLE_TIMEOUT_MS = 5 * 60 * 1000;
-      const HARD_CEILING_MS = 60 * 60 * 1000;
+      const engineTimeouts = rt.timeouts || {};
+      const IDLE_TIMEOUT_MS = engineTimeouts.idleMs || (5 * 60 * 1000);
+      const TOOL_EXEC_TIMEOUT_MS = engineTimeouts.toolMs || (25 * 60 * 1000);
+      const HARD_CEILING_MS = engineTimeouts.ceilingMs || (60 * 60 * 1000);
       const startTime = Date.now();
+      let waitingForTool = false;
 
       let sigkillTimer = null;
       function killChild(reason) {
         if (killed) return;
         killed = true;
         killedReason = reason;
-        log('WARN', `Claude ${reason} timeout for chatId ${chatId} — killing process group`);
-        try { process.kill(-child.pid, 'SIGTERM'); } catch { child.kill('SIGTERM'); }
+        log('WARN', `[${rt.name}] ${reason} timeout for chatId ${chatId} — killing process group`);
+        const sig = rt.killSignal || 'SIGTERM';
+        try { process.kill(-child.pid, sig); } catch { child.kill(sig); }
         sigkillTimer = setTimeout(() => {
           try { process.kill(-child.pid, 'SIGKILL'); } catch { try { child.kill('SIGKILL'); } catch { } }
         }, 5000);
@@ -376,10 +548,10 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
 
       function resetIdleTimer() {
         clearTimeout(idleTimer);
-        idleTimer = setTimeout(() => killChild('idle'), IDLE_TIMEOUT_MS);
+        const timeout = waitingForTool ? TOOL_EXEC_TIMEOUT_MS : IDLE_TIMEOUT_MS;
+        idleTimer = setTimeout(() => killChild('idle'), timeout);
       }
 
-      // ── 进度里程碑：2min 首报，之后每 5min 一次 ──
       let toolCallCount = 0;
       let lastMilestoneMin = 0;
       const milestoneTimer = setInterval(() => {
@@ -400,161 +572,182 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
         }
       }, 30000);
 
+      function parseEventsFromLine(line) {
+        try {
+          return rt.parseStreamEvent(line) || [];
+        } catch {
+          return [];
+        }
+      }
+
       child.stdout.on('data', (data) => {
         resetIdleTimer();
         buffer += data.toString();
-
-        // Process complete JSON lines
         const lines = buffer.split('\n');
-        buffer = lines.pop() || ''; // Keep incomplete line in buffer
+        buffer = lines.pop() || '';
 
         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');
+          if (!_firstOutputLogged) {
+            _firstOutputLogged = true;
+            log('INFO', `[TIMING:${chatId}] first-line +${Date.now() - _spawnAt}ms`);
+          }
+          const events = parseEventsFromLine(line);
+          for (const event of events) {
+            if (!event || !event.type) continue;
+            if (event.type === 'session' && event.sessionId) {
+              observedSessionId = String(event.sessionId);
+              if (typeof onSession === 'function') {
+                Promise.resolve(onSession(observedSessionId)).catch(() => { });
               }
+              continue;
             }
-
-            // 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') {
-                  toolCallCount++;
-                  const toolName = block.name || 'Tool';
-
-                  // Track tool usage for skill evolution
-                  const toolEntry = { tool: toolName };
-                  if (toolName === 'Skill' && block.input?.skill) toolEntry.skill = block.input.skill;
-                  else if (block.input?.command) toolEntry.context = block.input.command.slice(0, 50);
-                  else if (block.input?.file_path) toolEntry.context = path.basename(block.input.file_path);
-                  if (toolUsageLog.length < 50) toolUsageLog.push(toolEntry);
-
-                  // 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;
-
-                    // Resolve display name and context for MCP/Skill/Task tools
-                    let displayName = toolName;
-                    let displayEmoji = emoji;
-                    let context = '';
-
-                    if (toolName === 'Skill' && block.input?.skill) {
-                      // Skill invocation: show skill name
-                      context = block.input.skill;
-                    } else if (toolName === 'Task' && block.input?.description) {
-                      // Agent task: show description
-                      context = block.input.description.slice(0, 30);
-                    } else if (toolName.startsWith('mcp__')) {
-                      // MCP tool: mcp__server__action → "MCP server: action"
-                      const parts = toolName.split('__');
-                      const server = parts[1] || 'unknown';
-                      const action = parts.slice(2).join('_') || '';
-                      if (server === 'playwright') {
-                        displayEmoji = '🌐';
-                        displayName = 'Browser';
-                        context = action.replace(/_/g, ' ');
-                      } else {
-                        displayEmoji = '🔗';
-                        displayName = `MCP:${server}`;
-                        context = action.replace(/_/g, ' ').slice(0, 25);
-                      }
-                    } else if (block.input) {
-                      // Standard tools: extract brief context
-                      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
-                      ? `${displayEmoji} ${displayName}: 「${context}」`
-                      : `${displayEmoji} ${displayName}...`;
-
-                    if (onStatus) {
-                      onStatus(status).catch(() => { });
-                    }
-                  }
-                }
+            if (event.type === 'error') {
+              classifiedError = event;
+              continue;
+            }
+            if (event.type === 'text' && event.text) {
+              finalResult = String(event.text);
+              if (waitingForTool) {
+                waitingForTool = false;
+                resetIdleTimer();
+              }
+              continue;
+            }
+            if (event.type === 'done') {
+              finalUsage = event.usage || null;
+              if (waitingForTool) {
+                waitingForTool = false;
+                resetIdleTimer();
+              }
+              continue;
+            }
+            if (event.type === 'tool_result') {
+              if (waitingForTool) {
+                waitingForTool = false;
+                resetIdleTimer();
               }
+              continue;
+            }
+            if (event.type !== 'tool_use') continue;
+
+            toolCallCount++;
+            waitingForTool = true;
+            resetIdleTimer();
+            const toolName = event.toolName || 'Tool';
+            const toolInput = event.toolInput || {};
+
+            const toolEntry = { tool: toolName };
+            if (toolName === 'Skill' && toolInput.skill) toolEntry.skill = toolInput.skill;
+            else if (toolInput.command) toolEntry.context = String(toolInput.command).slice(0, 50);
+            else if (toolInput.file_path) toolEntry.context = path.basename(String(toolInput.file_path));
+            if (toolUsageLog.length < 50) toolUsageLog.push(toolEntry);
+
+            if (toolName === 'Write' && toolInput.file_path) {
+              const filePath = String(toolInput.file_path);
+              if (!writtenFiles.includes(filePath)) writtenFiles.push(filePath);
             }
 
-            // Also check for result message type
-            if (event.type === 'result' && event.result) {
-              finalResult = event.result;
+            const now = Date.now();
+            if (now - lastStatusTime < STATUS_THROTTLE) continue;
+            lastStatusTime = now;
+
+            const emoji = TOOL_EMOJI[toolName] || TOOL_EMOJI.default;
+            let displayName = toolName;
+            let displayEmoji = emoji;
+            let context = '';
+
+            if (toolName === 'Skill' && toolInput.skill) {
+              context = toolInput.skill;
+            } else if (toolName === 'Task' && toolInput.description) {
+              context = String(toolInput.description).slice(0, 30);
+            } else if (toolName.startsWith('mcp__')) {
+              const parts = toolName.split('__');
+              const server = parts[1] || 'unknown';
+              const action = parts.slice(2).join('_') || '';
+              if (server === 'playwright') {
+                displayEmoji = '🌐';
+                displayName = 'Browser';
+                context = action.replace(/_/g, ' ');
+              } else {
+                displayEmoji = '🔗';
+                displayName = `MCP:${server}`;
+                context = action.replace(/_/g, ' ').slice(0, 25);
+              }
+            } else if (toolInput.file_path) {
+              const basename = path.basename(String(toolInput.file_path));
+              const dotIdx = basename.lastIndexOf('.');
+              context = dotIdx > 0 ? basename.slice(0, dotIdx) + '\u200B' + basename.slice(dotIdx) : basename;
+            } else if (toolInput.command) {
+              context = String(toolInput.command).slice(0, 30);
+              if (String(toolInput.command).length > 30) context += '...';
+            } else if (toolInput.pattern) {
+              context = String(toolInput.pattern).slice(0, 20);
+            } else if (toolInput.query) {
+              context = String(toolInput.query).slice(0, 25);
+            } else if (toolInput.url) {
+              try { context = new URL(toolInput.url).hostname; } catch { context = 'web'; }
             }
-          } catch {
-            // Not valid JSON, ignore
+
+            const status = context
+              ? `${displayEmoji} ${displayName}: 「${context}」`
+              : `${displayEmoji} ${displayName}...`;
+            if (onStatus) onStatus(status).catch(() => { });
           }
         }
       });
 
       child.stderr.on('data', (data) => {
         resetIdleTimer();
-        stderr += data.toString();
+        const chunk = data.toString();
+        stderr += chunk;
+        if (!classifiedError && typeof rt.classifyError === 'function') {
+          classifiedError = rt.classifyError(chunk);
+        }
       });
 
       child.on('close', (code) => {
+        log('INFO', `[TIMING:${chatId}] process-close code=${code} total=${Date.now() - _spawnAt}ms`);
         clearTimeout(idleTimer);
         clearTimeout(ceilingTimer);
         clearTimeout(sigkillTimer);
         clearInterval(milestoneTimer);
 
-        // Process any remaining buffer
         if (buffer.trim()) {
-          try {
-            const event = JSON.parse(buffer);
-            if (event.type === 'result' && event.result) {
-              finalResult = event.result;
-            }
-          } catch { /* ignore */ }
+          const events = parseEventsFromLine(buffer.trim());
+          for (const event of events) {
+            if (event.type === 'text' && event.text) finalResult = String(event.text);
+            if (event.type === 'done') finalUsage = event.usage || null;
+            if (event.type === 'session' && event.sessionId) observedSessionId = String(event.sessionId);
+            if (event.type === 'error') classifiedError = event;
+          }
         }
 
-        // Clean up active process tracking
         const proc = chatId ? activeProcesses.get(chatId) : null;
         const wasAborted = proc && proc.aborted;
-        if (chatId) { activeProcesses.delete(chatId); saveActivePids(); } // Fix3
+        if (chatId) { activeProcesses.delete(chatId); saveActivePids(); }
 
         if (wasAborted) {
-          resolve({ output: finalResult || null, error: 'Stopped by user', files: writtenFiles, toolUsageLog });
-        } else if (killed) {
+          finalize({ output: finalResult || null, error: 'Stopped by user', files: writtenFiles, toolUsageLog, usage: finalUsage, sessionId: observedSessionId || '' });
+          return;
+        }
+        if (killed) {
           const elapsed = Math.round((Date.now() - startTime) / 60000);
+          const idleMin = Math.max(1, Math.round(IDLE_TIMEOUT_MS / 60000));
           const reason = killedReason === 'ceiling'
-            ? `⏱ 已运行 ${elapsed} 分钟，达到上限（1 小时）`
-            : `⏱ 已 5 分钟无输出，判定卡死（共运行 ${elapsed} 分钟）`;
-          resolve({ output: finalResult || null, error: reason, timedOut: true, files: writtenFiles, toolUsageLog });
-        } else if (code !== 0) {
-          resolve({ output: finalResult || null, error: stderr || `Exit code ${code}`, files: writtenFiles, toolUsageLog });
-        } else {
-          resolve({ output: finalResult || '', error: null, files: writtenFiles, toolUsageLog });
+            ? `⏱ 已运行 ${elapsed} 分钟，达到上限（${Math.round(HARD_CEILING_MS / 60000)} 分钟）`
+            : `⏱ 已 ${idleMin} 分钟无输出，判定卡死（共运行 ${elapsed} 分钟）`;
+          finalize({ output: finalResult || null, error: reason, timedOut: true, files: writtenFiles, toolUsageLog, usage: finalUsage, sessionId: observedSessionId || '' });
+          return;
+        }
+        if (code !== 0) {
+          const engineErr = classifiedError && classifiedError.message
+            ? classifiedError.message
+            : (stderr || `Exit code ${code}`);
+          finalize({ output: finalResult || null, error: engineErr, errorCode: classifiedError ? classifiedError.code : undefined, files: writtenFiles, toolUsageLog, usage: finalUsage, sessionId: observedSessionId || '' });
+          return;
         }
+        finalize({ output: finalResult || '', error: null, files: writtenFiles, toolUsageLog, usage: finalUsage, sessionId: observedSessionId || '' });
       });
 
       child.on('error', (err) => {
@@ -562,13 +755,28 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
         clearTimeout(ceilingTimer);
         clearTimeout(sigkillTimer);
         clearInterval(milestoneTimer);
-        if (chatId) { activeProcesses.delete(chatId); saveActivePids(); } // Fix3
-        resolve({ output: null, error: err.message, files: [], toolUsageLog: [] });
+        if (chatId) { activeProcesses.delete(chatId); saveActivePids(); }
+        finalize({ output: null, error: formatEngineSpawnError(err, rt), files: [], toolUsageLog: [], usage: null, sessionId: '' });
       });
 
-      // Write input and close stdin
-      child.stdin.write(input);
-      child.stdin.end();
+      try {
+        child.stdin.write(input);
+        child.stdin.end();
+      } catch (e) {
+        clearTimeout(idleTimer);
+        clearTimeout(ceilingTimer);
+        clearTimeout(sigkillTimer);
+        clearInterval(milestoneTimer);
+        if (chatId) { activeProcesses.delete(chatId); saveActivePids(); }
+        try { child.stdin.destroy(); } catch { /* ignore */ }
+        try {
+          const sig = rt.killSignal || 'SIGTERM';
+          process.kill(-child.pid, sig);
+        } catch {
+          try { child.kill(rt.killSignal || 'SIGTERM'); } catch { /* ignore */ }
+        }
+        finalize({ output: null, error: e.message, files: [], toolUsageLog: [], usage: null, sessionId: '' });
+      }
     });
   }
 
@@ -578,7 +786,7 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
     if (!messageId || !session || !session.id) return;
     const st = loadState();
     if (!st.msg_sessions) st.msg_sessions = {};
-    st.msg_sessions[messageId] = { id: session.id, cwd: session.cwd };
+    st.msg_sessions[messageId] = { id: session.id, cwd: session.cwd, engine: session.engine || getDefaultEngine() };
     const keys = Object.keys(st.msg_sessions);
     if (keys.length > 200) {
       for (const k of keys.slice(0, keys.length - 200)) delete st.msg_sessions[k];
@@ -608,6 +816,7 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
   }
 
   async function askClaude(bot, chatId, prompt, config, readOnly = false) {
+    const _t0 = Date.now();
     log('INFO', `askClaude for ${chatId}: ${prompt.slice(0, 50)}`);
     // Track interaction time for idle/sleep detection
     if (touchInteraction) touchInteraction();
@@ -619,19 +828,24 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
         saveState(_st);
       }
     } catch { /* non-critical */ }
-    // Send a single status message, updated in-place, deleted on completion
+    // Send 🤔 ack and start typing — fire-and-forget so we don't block spawn on Telegram RTT.
+    // statusMsgId is resolved via a promise; it will be ready well before the first model output.
     let statusMsgId = null;
-    try {
-      const msg = await (bot.sendMarkdown ? bot.sendMarkdown(chatId, '🤔') : bot.sendMessage(chatId, '🤔'));
-      if (msg && msg.message_id) statusMsgId = msg.message_id;
-    } catch (e) {
-      log('ERROR', `Failed to send ack to ${chatId}: ${e.message}`);
-    }
-    await bot.sendTyping(chatId).catch(() => { });
+    // 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).
+    (bot.sendMarkdown ? bot.sendMarkdown(chatId, '🤔') : bot.sendMessage(chatId, '🤔'))
+      .then(msg => { if (msg && msg.message_id) statusMsgId = msg.message_id; })
+      .catch(e => log('ERROR', `Failed to send ack to ${chatId}: ${e.message}`));
+    bot.sendTyping(chatId).catch(() => { });
     const typingTimer = setInterval(() => {
       bot.sendTyping(chatId).catch(() => { });
     }, 4000);
 
+    // Top-level safety net: any uncaught error inside askClaude MUST clean up timers and notify user.
+    // Without this, a ReferenceError / TypeError in the routing or injection code would silently
+    // kill the handler, leaving the typing indicator spinning forever.
+    try { // ── safety-net-start ──
+
     // Agent nickname routing: "贾维斯" / "小美，帮我..." → switch project session
     // Strict chats (chat_agent_map bound groups) must NOT switch agents via nickname
     const _strictAgentMap = { ...(config.telegram ? config.telegram.chat_agent_map : {}), ...(config.feishu ? config.feishu.chat_agent_map : {}) };
@@ -640,7 +854,7 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
     if (agentMatch) {
       const { key, proj, rest } = agentMatch;
       const projCwd = normalizeCwd(proj.cwd);
-      attachOrCreateSession(chatId, projCwd, proj.name || key);
+      attachOrCreateSession(chatId, projCwd, proj.name || key, proj.engine ? normalizeEngineName(proj.engine) : getDefaultEngine());
       log('INFO', `Agent switch via nickname: ${key} (${projCwd})`);
       if (!rest) {
         // Pure nickname call — confirm switch and stop
@@ -655,100 +869,140 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
     // Skill routing: detect skill first, then decide session
     // BUT: skip skill routing if agent addressed by nickname OR chat already has an active session
     // (active conversation should never be hijacked by keyword-based skill matching)
-    let session = getSession(chatId);
-    const hasActiveSession = session && session.started;
-    const skill = (agentMatch || hasActiveSession) ? null : routeSkill(prompt);
+    const sessionRaw = getSession(chatId);
     const chatIdStr = String(chatId);
     const chatAgentMap = { ...(config.telegram ? config.telegram.chat_agent_map : {}), ...(config.feishu ? config.feishu.chat_agent_map : {}) };
     const boundProjectKey = chatAgentMap[chatIdStr] || projectKeyFromVirtualChatId(chatIdStr);
     const boundProject = boundProjectKey && config.projects ? config.projects[boundProjectKey] : null;
     const boundCwd = (boundProject && boundProject.cwd) ? normalizeCwd(boundProject.cwd) : null;
+    const boundEngineName = (boundProject && boundProject.engine) ? normalizeEngineName(boundProject.engine) : getDefaultEngine();
+
+    // Engine is determined from config only — bound agent config wins, then global default.
+    const engineName = normalizeEngineName(
+      (boundProject && boundProject.engine) || getDefaultEngine()
+    );
+    const runtime = getEngineRuntime(engineName);
+
+    // hasActiveSession: does the current engine have an ongoing conversation?
+    const hasActiveSession = sessionRaw && (
+      sessionRaw.engines ? !!(sessionRaw.engines[engineName]?.started) : !!sessionRaw.started
+    );
+    const skill = (agentMatch || hasActiveSession) ? null : routeSkill(prompt);
 
-    if (!session) {
-      if (boundCwd) {
-        // Agent-bound chats must stay in their own workspace: never attach to another project's session.
-        const recentInBound = listRecentSessions(1, boundCwd);
-        if (recentInBound.length > 0 && recentInBound[0].sessionId) {
-          const target = recentInBound[0];
-          const state = loadState();
-          state.sessions[chatId] = {
-            id: target.sessionId,
-            cwd: boundCwd,
-            started: true,
-          };
-          saveState(state);
-          session = state.sessions[chatId];
-          log('INFO', `Auto-attached ${chatId} to bound-session: ${target.sessionId.slice(0, 8)} (${path.basename(boundCwd)})`);
-        } else {
-          session = createSession(chatId, boundCwd, boundProject && boundProject.name ? boundProject.name : '');
-          log('INFO', `Created fresh session for bound workspace: ${path.basename(boundCwd)}`);
-        }
-      } else {
-        // Non-bound chats keep legacy behavior: attach global recent, else create.
-        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,
-          };
-          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);
-        }
+    if (!sessionRaw) {
+      // No saved state for this chatId: start a fresh session.
+      // Note: daemon_state.json persists across restarts, so this only happens on truly first use
+      // or after an explicit /new command.
+      createSession(chatId, boundCwd || undefined, boundProject && boundProject.name ? boundProject.name : '', boundEngineName);
+    }
+
+    // Resolve flat view for current engine (id + started are engine-specific; cwd is shared)
+    let session = getSessionForEngine(chatId, engineName) || { cwd: boundCwd || HOME, engine: engineName, id: null, started: false };
+    session.engine = engineName; // keep local copy for Codex resume detection below
+
+    // Pre-spawn session validation: unified for all engines.
+    // Claude checks JSONL file existence; Codex checks SQLite. Same interface, different backend.
+    if (session.started && session.id && session.id !== '__continue__' && session.cwd) {
+      const valid = isEngineSessionValid(engineName, session.id, session.cwd);
+      if (!valid) {
+        log('WARN', `${engineName} session ${session.id.slice(0, 8)} invalid for ${chatId}; starting fresh ${engineName} session`);
+        await bot.sendMessage(chatId, '⚠️ 上次 session 已失效，已自动开启新 session。').catch(() => {});
+        session = createSession(chatId, session.cwd, boundProject && boundProject.name ? boundProject.name : '', engineName);
       }
     }
 
-    // Safety guard: prevent stale state from resuming another workspace's session.
-    if (!usePinnedSkillSession && session && session.started && session.id && session.id !== '__continue__' && session.cwd) {
-      const sessionCwd = normalizeCwd(session.cwd);
-      const existsInCwd = isSessionInCwd(session.id, sessionCwd);
-      if (!existsInCwd) {
-        log('WARN', `Session mismatch detected for ${chatId}: ${session.id.slice(0, 8)} not found in ${sessionCwd}; creating fresh session`);
-        session = createSession(chatId, sessionCwd, boundProject && boundProject.name ? boundProject.name : '');
+    const daemonCfg = (config && config.daemon) || {};
+    const mentorCfg = (daemonCfg.mentor && typeof daemonCfg.mentor === 'object') ? daemonCfg.mentor : {};
+    const mentorEnabled = !!(mentorEngine && mentorCfg.enabled);
+    const excludeAgents = new Set(
+      (Array.isArray(mentorCfg.exclude_agents) ? mentorCfg.exclude_agents : [])
+        .map(x => String(x || '').trim())
+        .filter(Boolean)
+    );
+    const chatAgentKey = boundProjectKey || 'personal';
+    const mentorExcluded = excludeAgents.has(chatAgentKey);
+    let mentorSuppressed = false;
+
+    // Mentor pre-flight breaker: first hit sends a short reassurance; cooldown does not block normal answers.
+    if (mentorEnabled && !mentorExcluded) {
+      try {
+        const breaker = mentorEngine.checkEmotionBreaker(prompt, mentorCfg);
+        if (breaker && breaker.tripped) {
+          mentorSuppressed = true;
+          if (breaker.reason !== 'cooldown_active' && breaker.response) {
+            await bot.sendMessage(chatId, breaker.response).catch(() => { });
+          }
+        }
+      } catch (e) {
+        log('WARN', `Mentor breaker failed: ${e.message}`);
       }
     }
 
-    // Build claude command
-    const args = ['-p'];
-    const daemonCfg = loadConfig().daemon || {};
-    const model = daemonCfg.model || 'opus';
-    args.push('--model', model);
-    if (readOnly) {
-      // Read-only mode for non-operator users: query/chat only, no write/edit/execute
-      const READ_ONLY_TOOLS = ['Read', 'Glob', 'Grep', 'WebSearch', 'WebFetch', 'Task'];
-      for (const tool of READ_ONLY_TOOLS) args.push('--allowedTools', tool);
-    } else if (daemonCfg.dangerously_skip_permissions) {
-      args.push('--dangerously-skip-permissions');
-    } else {
-      const sessionAllowed = daemonCfg.session_allowed_tools || [];
-      for (const tool of sessionAllowed) args.push('--allowedTools', tool);
+    // Build engine command — prefer per-engine model, fall back to legacy daemon.model
+    const engineModels = daemonCfg.models || {};
+    const engineModel = engineModels[runtime.name] || daemonCfg.model || runtime.defaultModel;
+    const model = (boundProject && boundProject.model) || engineModel;
+    const args = runtime.buildArgs({
+      model,
+      readOnly,
+      daemonCfg,
+      session,
+      cwd: session.cwd,
+    });
+
+    // Codex: write/refresh AGENTS.md = CLAUDE.md + SOUL.md on every new session.
+    // Written as a real file (not a symlink) for Windows compatibility.
+    // Refreshed each session so edits to CLAUDE.md or SOUL.md are always picked up.
+    // Codex auto-loads AGENTS.md from cwd and all parent dirs up to ~.
+    if (engineName === 'codex' && session.cwd && !session.started) {
+      try {
+        const parts = [];
+        const claudeMd = path.join(session.cwd, 'CLAUDE.md');
+        const soulMd = path.join(session.cwd, 'SOUL.md');
+        if (fs.existsSync(claudeMd)) parts.push(fs.readFileSync(claudeMd, 'utf8').trim());
+        if (fs.existsSync(soulMd)) {
+          const soulContent = fs.readFileSync(soulMd, 'utf8').trim();
+          if (soulContent) parts.push(soulContent);
+        }
+        if (parts.length > 0) {
+          fs.writeFileSync(path.join(session.cwd, 'AGENTS.md'), parts.join('\n\n'), 'utf8');
+          log('INFO', `Refreshed AGENTS.md (${parts.length} section(s)) in ${session.cwd}`);
+        }
+      } catch (e) {
+        log('WARN', `AGENTS.md refresh failed: ${e.message}`);
+      }
     }
-    if (session.id === '__continue__') {
-      args.push('--continue');
-    } else if (session.started) {
-      args.push('--resume', session.id);
-    } else {
-      args.push('--session-id', session.id);
+
+    let agentHint = '';
+    if (!session.started && (boundProject || (session && session.cwd))) {
+      try {
+        // Engine-aware: Codex gets memory only (soul is already in AGENTS.md);
+        // Claude gets soul + memory (SOUL.md is not auto-loaded by Claude).
+        agentHint = buildAgentContextForEngine(
+          boundProject || { cwd: session.cwd },
+          engineName,
+          HOME,
+        ).hint || '';
+      } catch (e) {
+        log('WARN', `Agent context injection failed: ${e.message}`);
+      }
     }
 
     // Memory & Knowledge Injection (RAG)
     let memoryHint = '';
+    // projectKey must be declared outside the try block so the daemonHint template below can reference it.
+    const _cid0 = String(chatId);
+    const _agentMap0 = { ...(config.telegram ? config.telegram.chat_agent_map : {}), ...(config.feishu ? config.feishu.chat_agent_map : {}) };
+    const projectKey = _agentMap0[_cid0] || projectKeyFromVirtualChatId(_cid0);
     try {
       const memory = require('./memory');
-      const _cid = String(chatId);
-      const _cfg = loadConfig();
-      const _agentMap = { ...(_cfg.telegram ? _cfg.telegram.chat_agent_map : {}), ...(_cfg.feishu ? _cfg.feishu.chat_agent_map : {}) };
-      const projectKey = _agentMap[_cid] || projectKeyFromVirtualChatId(_cid);
 
-      // L1: NOW.md shared whiteboard injection
+      // L1: NOW.md per-agent whiteboard injection（按 projectKey 隔离，防并发冲突）
       if (!session.started) {
         try {
-          const nowPath = path.join(HOME, '.metame', 'memory', 'NOW.md');
+          const nowDir = path.join(HOME, '.metame', 'memory', 'now');
+          const nowKey = projectKey || 'default';
+          const nowPath = path.join(nowDir, `${nowKey}.md`);
           if (fs.existsSync(nowPath)) {
             const nowContent = fs.readFileSync(nowPath, 'utf8').trim();
             if (nowContent) {
@@ -788,11 +1042,13 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
 
     // ZPD: build competence hint from brain profile
     let zdpHint = '';
+    let brainDoc = null;
     if (!session.started) {
       try {
         const brainPath = path.join(HOME, '.claude_profile.yaml');
         if (fs.existsSync(brainPath)) {
           const brain = yaml.load(fs.readFileSync(brainPath, 'utf8'));
+          brainDoc = brain;
           const cmap = brain && brain.user_competence_map;
           if (cmap && typeof cmap === 'object' && Object.keys(cmap).length > 0) {
             const lines = Object.entries(cmap)
@@ -803,6 +1059,12 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
         }
       } catch { /* non-critical */ }
     }
+    if (!brainDoc) {
+      try {
+        const brainPath = path.join(HOME, '.claude_profile.yaml');
+        if (fs.existsSync(brainPath)) brainDoc = yaml.load(fs.readFileSync(brainPath, 'utf8')) || {};
+      } catch { /* ignore */ }
+    }
 
     // Inject daemon hints only on first message of a session
     // Task-specific rules (3-5) are injected only when isTaskIntent() returns true (~250 token saving for casual chat)
@@ -818,9 +1080,9 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
    Valid relations: tech_decision, bug_lesson, arch_convention, config_fact, config_change, workflow_rule, project_milestone
    Only write verified facts. Do not write speculative or process-description entries.
    When you observe the user is clearly expert or beginner in a domain, note it in your response and suggest: "要不要把你的 {domain} 水平 ({level}) 记录到能力雷达？"
-5. Task handoff: When suspending a multi-step task or handing off to another agent, write current status to ~/.metame/memory/NOW.md using:
-   \`printf '%s\\n' "## Current Task" "{task}" "" "## Progress" "{progress}" "" "## Next Step" "{next}" > ~/.metame/memory/NOW.md\`
-   Keep it under 200 words. Clear it when the task is fully complete by running: \`> ~/.metame/memory/NOW.md\`` : '';
+5. Task handoff: When suspending a multi-step task or handing off to another agent, write current status to ~/.metame/memory/now/${projectKey || 'default'}.md using:
+   \`mkdir -p ~/.metame/memory/now && printf '%s\\n' "## Current Task" "{task}" "" "## Progress" "{progress}" "" "## Next Step" "{next}" > ~/.metame/memory/now/${projectKey || 'default'}.md\`
+   Keep it under 200 words. Clear it when the task is fully complete by running: \`> ~/.metame/memory/now/${projectKey || 'default'}.md\`` : '';
       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:
@@ -829,7 +1091,9 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
    - Add at END of response: [[FILE:/absolute/path/to/file]]
    - Keep response brief: "请查收~! [[FILE:/path/to/file]]"
    - Multiple files: use multiple [[FILE:...]] tags${zdpHint ? '\n   Explanation depth (ZPD):\n' + zdpHint : ''}${taskRules}]`;
-    }
+   }
+
+    daemonHint = adaptDaemonHintForEngine(daemonHint, runtime.name);
 
     const routedPrompt = skill ? `/${skill} ${prompt}` : prompt;
 
@@ -865,13 +1129,71 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
       } catch { /* non-critical */ }
     }
 
-    // Always append a compact language guard to prevent accidental Korean/Japanese responses
-    const langGuard = '\n\n[Respond in Simplified Chinese (简体中文) only. NEVER switch to Korean, Japanese, or other languages regardless of tool output or context language.]';
-    const fullPrompt = routedPrompt + daemonHint + macAutomationHint + summaryHint + memoryHint + langGuard;
+    // Mentor context hook: inject after memoryHint, before langGuard.
+    let mentorHint = '';
+    if (mentorEnabled && !mentorExcluded && !mentorSuppressed) {
+      try {
+        const signals = collectRecentSessionSignals(session.id, 6);
+        let skeleton = null;
+        if (sessionAnalytics && typeof sessionAnalytics.extractSkeleton === 'function') {
+          const file = findSessionFile(session.id);
+          if (file && fs.existsSync(file)) {
+            const st = fs.statSync(file);
+            if (st.size <= 2 * 1024 * 1024) {
+              skeleton = sessionAnalytics.extractSkeleton(file);
+            }
+          }
+        }
+        const zone = skeleton && mentorEngine.computeZone
+          ? mentorEngine.computeZone(skeleton).zone
+          : 'stretch';
+        const sessionState = {
+          zone,
+          recentMessages: signals.recentMessages,
+          cwd: session.cwd,
+          skeleton,
+          sessionStartTime: signals.sessionStartTime || new Date().toISOString(),
+          topic: String(prompt || '').slice(0, 120),
+          currentTopic: String(prompt || '').slice(0, 120),
+          lastUserMessage: String(prompt || '').slice(0, 200),
+        };
+        const built = mentorEngine.buildMentorPrompt(sessionState, brainDoc || {}, mentorCfg);
+        if (built && String(built).trim()) mentorHint = `\n\n${String(built).trim()}`;
+
+        // Collect reflection debt: if user returns to same project+topic, inject recall prompt.
+        // Suppressed by quiet_until (user explicitly asked for silence), but NOT by expert skip
+        // (even experts may not have reviewed AI-generated code).
+        const quietUntil = brainDoc && brainDoc.growth ? brainDoc.growth.quiet_until : null;
+        const quietMs = quietUntil ? new Date(quietUntil).getTime() : 0;
+        const isQuiet = quietMs && quietMs > Date.now();
+        if (!isQuiet && mentorEngine.collectDebt) {
+          const info = deriveProjectInfo(session && session.cwd ? session.cwd : '');
+          const projectId = info && info.project_id ? info.project_id : '';
+          if (projectId) {
+            const debt = mentorEngine.collectDebt(projectId, String(prompt || '').slice(0, 120));
+            if (debt && debt.prompt) {
+              mentorHint += `\n\n[Reflection debt] ${debt.prompt}`;
+            }
+          }
+        }
+      } catch (e) {
+        log('WARN', `Mentor prompt build failed: ${e.message}`);
+      }
+    }
+
+    // Language guard: only inject on first message of a new session to avoid
+    // linearly growing token cost on every turn in long conversations.
+    // Claude Code preserves session context, so the guard persists after initial injection.
+    const langGuard = session.started
+      ? ''
+      : '\n\n[Respond in Simplified Chinese (简体中文) only. NEVER switch to Korean, Japanese, or other languages regardless of tool output or context language.]';
+    const fullPrompt = routedPrompt + daemonHint + agentHint + macAutomationHint + summaryHint + memoryHint + mentorHint + langGuard;
 
-    // Git checkpoint before Claude modifies files (for /undo)
-    // Pass the user prompt as label so checkpoint list is human-readable
-    gitCheckpoint(session.cwd, prompt);
+    // Git checkpoint before Claude modifies files (for /undo).
+    // Run async (fire-and-forget) to avoid blocking Claude spawn by ~600ms.
+    // Completes well before Claude's first file write (~2s after spawn).
+    (gitCheckpointAsync || gitCheckpoint)(session.cwd, prompt).catch?.(() => {});
+    log('INFO', `[TIMING:${chatId}] pre-spawn +${Date.now() - _t0}ms (engine:${runtime.name} started:${session.started})`);
 
     // Use streaming mode to show progress
     // Telegram: edit status msg in-place; Feishu: edit or fallback to new messages
@@ -893,9 +1215,103 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
       } catch { /* ignore status update failures */ }
     };
 
-    let output, error, files, toolUsageLog, timedOut;
+    const wasCodexResumeAttempt = runtime.name === 'codex'
+      && !!(session && session.started && session.id && session.id !== '__continue__');
+    const onSession = async (nextSessionId) => {
+      const safeNextId = String(nextSessionId || '').trim();
+      if (!safeNextId) return;
+      const prevSessionId = session && session.id ? String(session.id) : '';
+      const wasStarted = !!(session && session.started);
+      session = {
+        ...session,
+        id: safeNextId,
+        engine: runtime.name,
+        started: true,
+      };
+      await patchSessionSerialized(chatId, (cur) => {
+        const engines = { ...(cur.engines || {}) };
+        engines[runtime.name] = { ...(engines[runtime.name] || {}), id: safeNextId, started: true };
+        return { ...cur, cwd: session.cwd || cur.cwd || HOME, engines };
+      });
+      if (runtime.name === 'codex' && wasStarted && prevSessionId && prevSessionId !== safeNextId && prevSessionId !== '__continue__') {
+        log('WARN', `Codex thread migrated for ${chatId}: ${prevSessionId.slice(0, 8)} -> ${safeNextId.slice(0, 8)}`);
+      }
+    };
+
+    let output, error, errorCode, files, toolUsageLog, timedOut, usage, sessionId;
     try {
-      ({ output, error, timedOut, files, toolUsageLog } = await spawnClaudeStreaming(args, fullPrompt, session.cwd, onStatus, 600000, chatId, boundProjectKey || ''));
+      ({
+        output,
+        error,
+        errorCode,
+        timedOut,
+        files,
+        toolUsageLog,
+        usage,
+        sessionId,
+      } = await spawnClaudeStreaming(
+        args,
+        fullPrompt,
+        session.cwd,
+        onStatus,
+        600000,
+        chatId,
+        boundProjectKey || '',
+        runtime,
+        onSession,
+      ));
+
+      if (sessionId) await onSession(sessionId);
+
+      if (shouldRetryCodexResumeFallback({
+        runtimeName: runtime.name,
+        wasResumeAttempt: wasCodexResumeAttempt,
+        output,
+        error,
+        errorCode,
+        canRetry: canRetryCodexResume(chatId),
+      })) {
+        markCodexResumeRetried(chatId);
+        log('WARN', `Codex resume failed for ${chatId}, retrying once with fresh exec: ${String(error).slice(0, 120)}`);
+        // Notify user explicitly — silent context loss is worse than a visible warning.
+        await bot.sendMessage(chatId, '⚠️ Codex session 已过期，上下文丢失。正在以全新 session 重试，请在回复后补充必要背景。').catch(() => {});
+        session = createSession(
+          chatId,
+          session.cwd,
+          boundProject && boundProject.name ? boundProject.name : '',
+          'codex'
+        );
+        const retryArgs = runtime.buildArgs({
+          model,
+          readOnly,
+          daemonCfg,
+          session,
+          cwd: session.cwd,
+        });
+        // Prepend a context-loss marker so Codex knows this is a fresh session mid-conversation.
+        const retryPrompt = `[Note: previous Codex session expired and could not be resumed. Treating this as a new session. User message follows:]\n\n${fullPrompt}`;
+        ({
+          output,
+          error,
+          errorCode,
+          timedOut,
+          files,
+          toolUsageLog,
+          usage,
+          sessionId,
+        } = await spawnClaudeStreaming(
+          retryArgs,
+          retryPrompt,
+          session.cwd,
+          onStatus,
+          600000,
+          chatId,
+          boundProjectKey || '',
+          runtime,
+          onSession,
+        ));
+        if (sessionId) await onSession(sessionId);
+      }
     } catch (spawnErr) {
       clearInterval(typingTimer);
       if (statusMsgId && bot.deleteMessage) bot.deleteMessage(chatId, statusMsgId).catch(() => { });
@@ -921,6 +1337,24 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
       bot.deleteMessage(chatId, statusMsgId).catch(() => { });
     }
 
+    // Mentor post-flight debt registration (intense mode only).
+    if (mentorEnabled && !mentorExcluded && !mentorSuppressed && mentorEngine && typeof mentorEngine.registerDebt === 'function' && output) {
+      try {
+        const mode = resolveMentorMode(mentorCfg);
+        if (mode === 'intense') {
+          const codeLines = countCodeLines(output);
+          if (codeLines > 30) {
+            const info = deriveProjectInfo(session && session.cwd ? session.cwd : '');
+            const projectId = info && info.project_id ? info.project_id : 'proj_default';
+            mentorEngine.registerDebt(projectId, String(prompt || '').slice(0, 120), codeLines);
+            log('INFO', `[MENTOR] Registered reflection debt (${projectId}, lines=${codeLines})`);
+          }
+        }
+      } catch (e) {
+        log('WARN', `Mentor post-flight failed: ${e.message}`);
+      }
+    }
+
     // When Claude completes with no text output (pure tool work), send a done notice
     if (output === '' && !error) {
       // Special case: if dispatch_to was called, send a "forwarded" confirmation
@@ -934,36 +1368,39 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
         const doneMsg = await bot.sendMessage(chatId, `✉️ 已转达给 ${names}，处理中…`);
         if (doneMsg && doneMsg.message_id && session) trackMsgSession(doneMsg.message_id, session);
         const wasNew = !session.started;
-        if (wasNew) markSessionStarted(chatId);
+        if (wasNew) markSessionStarted(chatId, engineName);
         return { ok: true };
       }
       const filesDesc = files && files.length > 0 ? `\n修改了 ${files.length} 个文件` : '';
       const doneMsg = await bot.sendMessage(chatId, `✅ 完成${filesDesc}`);
       if (doneMsg && doneMsg.message_id && session) trackMsgSession(doneMsg.message_id, session);
       const wasNew = !session.started;
-      if (wasNew) markSessionStarted(chatId);
+      if (wasNew) markSessionStarted(chatId, engineName);
       return { ok: true };
     }
 
     if (output) {
+      if (runtime.name === 'codex') _codexResumeRetryTs.delete(String(chatId));
       // Detect provider/model errors disguised as output (e.g., "model not found", API errors)
-      const activeProvCheck = providerMod ? providerMod.getActiveName() : 'anthropic';
-      const builtinModelsCheck = ['sonnet', 'opus', 'haiku'];
-      const looksLikeError = output.length < 300 && /\b(not found|invalid model|unauthorized|401|403|404|error|failed)\b/i.test(output);
-      if (looksLikeError && (activeProvCheck !== 'anthropic' || !builtinModelsCheck.includes(model))) {
-        try {
-          config = fallbackToDefaultProvider(`output looks like error for ${activeProvCheck}/${model}`);
-          await bot.sendMessage(chatId, `⚠️ ${activeProvCheck}/${model} 疑似失败，已回退到 anthropic/opus\n输出: ${output.slice(0, 150)}`);
-        } catch (fbErr) {
-          log('ERROR', `Fallback failed: ${fbErr.message}`);
-          await bot.sendMarkdown(chatId, output);
+      if (runtime.name === 'claude') {
+        const activeProvCheck = providerMod ? providerMod.getActiveName() : 'anthropic';
+        const builtinModelsCheck = ['sonnet', 'opus', 'haiku'];
+        const looksLikeError = output.length < 300 && /\b(not found|invalid model|unauthorized|401|403|404|error|failed)\b/i.test(output);
+        if (looksLikeError && (activeProvCheck !== 'anthropic' || !builtinModelsCheck.includes(model))) {
+          try {
+            config = fallbackToDefaultProvider(`output looks like error for ${activeProvCheck}/${model}`);
+            await bot.sendMessage(chatId, `⚠️ ${activeProvCheck}/${model} 疑似失败，已回退到 anthropic/opus\n输出: ${output.slice(0, 150)}`);
+          } catch (fbErr) {
+            log('ERROR', `Fallback failed: ${fbErr.message}`);
+            await bot.sendMarkdown(chatId, output);
+          }
+          return { ok: false, error: output };
         }
-        return { ok: false, error: output };
       }
 
       // Mark session as started after first successful call
       const wasNew = !session.started;
-      if (wasNew) markSessionStarted(chatId);
+      if (wasNew) markSessionStarted(chatId, engineName);
 
       const estimated = Math.ceil((prompt.length + output.length) / 4);
       const chatCategory = classifyChatUsage(chatId, {
@@ -1019,57 +1456,102 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
       }
 
       // Auto-name: if this was the first message and session has no name, generate one
-      if (wasNew && !getSessionName(session.id)) {
+      if (runtime.name === 'claude' && wasNew && !getSessionName(session.id)) {
         autoNameSession(chatId, session.id, prompt, session.cwd).catch(() => { });
       }
+
+      // Auto-refresh memory-snapshot.md for this agent on first session message (fire-and-forget)
+      if (wasNew && boundProject && boundProject.agent_id) {
+        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 : [];
+            memory.close();
+            const snapshotContent = buildMemorySnapshotContent(sessions, facts);
+            const agentId = boundProject.agent_id;
+            if (refreshMemorySnapshot(agentId, snapshotContent, HOME)) {
+              log('DEBUG', `[AGENT] Memory snapshot refreshed for ${agentId}`);
+            }
+          } catch { /* non-critical — memory module may not be available */ }
+        });
+      }
       return { ok: !timedOut };
     } else {
       const errMsg = error || 'Unknown error';
-      log('ERROR', `askClaude failed for ${chatId}: ${errMsg.slice(0, 300)}`);
+      const userErrMsg = (errorCode === 'AUTH_REQUIRED' || errorCode === 'RATE_LIMIT')
+        ? errMsg
+        : `Error: ${errMsg.slice(0, 200)}`;
+      log('ERROR', `ask${runtime.name === 'codex' ? 'Codex' : 'Claude'} failed for ${chatId}: ${errMsg.slice(0, 300)} (${errorCode || 'NO_CODE'})`);
 
-      // If session not found (expired/deleted), create new and retry once
-      if (errMsg.includes('not found') || errMsg.includes('No session') || errMsg.includes('already in use')) {
+      // If session not found (expired/deleted), create new and retry once (Claude path)
+      if (runtime.name === 'claude' && (errMsg.includes('not found') || errMsg.includes('No session') || errMsg.includes('already in use'))) {
         log('WARN', `Session ${session.id} unusable (${errMsg.includes('already in use') ? 'locked' : 'not found'}), creating new`);
-        session = createSession(chatId, session.cwd);
-
-        const retryArgs = ['-p', '--session-id', session.id];
-        if (daemonCfg.dangerously_skip_permissions) {
-          retryArgs.push('--dangerously-skip-permissions');
-        } else {
-          const sessionAllowed = daemonCfg.session_allowed_tools || [];
-          for (const tool of sessionAllowed) retryArgs.push('--allowedTools', tool);
-        }
-
-        const retry = await spawnClaudeStreaming(retryArgs, prompt, session.cwd, onStatus);
+        session = createSession(chatId, session.cwd, '', runtime.name);
+
+        const retryArgs = runtime.buildArgs({
+          model,
+          readOnly,
+          daemonCfg,
+          session,
+          cwd: session.cwd,
+        });
+
+        const retry = await spawnClaudeStreaming(
+          retryArgs,
+          fullPrompt,
+          session.cwd,
+          onStatus,
+          600000,
+          chatId,
+          boundProjectKey || '',
+          runtime,
+          onSession,
+        );
+        if (retry.sessionId) await onSession(retry.sessionId);
         if (retry.output) {
-          markSessionStarted(chatId);
+          markSessionStarted(chatId, runtime.name);
           const { markedFiles: retryMarked, cleanOutput: retryClean } = parseFileMarkers(retry.output);
           await bot.sendMarkdown(chatId, retryClean);
           await sendFileButtons(bot, chatId, mergeFileCollections(retryMarked, retry.files));
           return { ok: true };
         } else {
           log('ERROR', `askClaude retry failed: ${(retry.error || '').slice(0, 200)}`);
-          try { await bot.sendMessage(chatId, `Error: ${(retry.error || '').slice(0, 200)}`); } catch { /* */ }
+          try { await bot.sendMessage(chatId, userErrMsg); } catch { /* */ }
           return { ok: false, error: retry.error || errMsg };
         }
       } else {
-        // Auto-fallback: if custom provider/model fails, revert to anthropic + opus
-        const activeProv = providerMod ? providerMod.getActiveName() : 'anthropic';
-        const builtinModels = ['sonnet', 'opus', 'haiku'];
-        if (activeProv !== 'anthropic' || !builtinModels.includes(model)) {
-          try {
-            config = fallbackToDefaultProvider(`${activeProv}/${model} error: ${errMsg.slice(0, 100)}`);
-            await bot.sendMessage(chatId, `⚠️ ${activeProv}/${model} 失败，已回退到 anthropic/opus\n原因: ${errMsg.slice(0, 100)}`);
-          } catch (fallbackErr) {
-            log('ERROR', `Fallback failed: ${fallbackErr.message}`);
-            try { await bot.sendMessage(chatId, `Error: ${errMsg.slice(0, 200)}`); } catch { /* */ }
+        // 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)) {
+            try {
+              config = fallbackToDefaultProvider(`${activeProv}/${model} error: ${errMsg.slice(0, 100)}`);
+              await bot.sendMessage(chatId, `⚠️ ${activeProv}/${model} 失败，已回退到 anthropic/opus\n原因: ${errMsg.slice(0, 100)}`);
+            } catch (fallbackErr) {
+              log('ERROR', `Fallback failed: ${fallbackErr.message}`);
+              try { await bot.sendMessage(chatId, userErrMsg); } catch { /* */ }
+            }
+          } else {
+            try { await bot.sendMessage(chatId, userErrMsg); } catch { /* */ }
           }
         } else {
-          try { await bot.sendMessage(chatId, `Error: ${errMsg.slice(0, 200)}`); } catch { /* */ }
+          try { await bot.sendMessage(chatId, userErrMsg); } catch { /* */ }
         }
-        return { ok: false, error: errMsg };
+        return { ok: false, error: errMsg, errorCode };
       }
     }
+
+    } catch (fatalErr) { // ── safety-net-catch ──
+      clearInterval(typingTimer);
+      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 { /* */ }
+      return { ok: false, error: fatalErr.message };
+    }
   }
 
   return {
@@ -1079,6 +1561,15 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
     spawnClaudeStreaming,
     trackMsgSession,
     askClaude,
+    _private: {
+      patchSessionSerialized,
+      shouldRetryCodexResumeFallback,
+      formatEngineSpawnError,
+      adaptDaemonHintForEngine,
+      canRetryCodexResume,
+      markCodexResumeRetried,
+      CODEX_RESUME_RETRY_WINDOW_MS,
+    },
   };
 }