metame-cli 1.4.33 → 1.5.0

package/scripts/daemon-session-commands.js

@@ -26,8 +26,24 @@ function createSessionCommandHandler(deps) {
     sessionRichLabel,
     buildSessionCardElements,
     sessionLabel,
+    getDefaultEngine = () => 'claude',
   } = deps;
 
+  function normalizeEngineName(name) {
+    const n = String(name || '').trim().toLowerCase();
+    return n === 'codex' ? 'codex' : getDefaultEngine();
+  }
+
+  function inferEngineByCwd(cfg, cwd) {
+    if (!cfg || !cfg.projects || !cwd) return null;
+    const target = normalizeCwd(cwd);
+    for (const proj of Object.values(cfg.projects || {})) {
+      if (!proj || !proj.cwd) continue;
+      if (normalizeCwd(proj.cwd) === target) return normalizeEngineName(proj.engine);
+    }
+    return null;
+  }
+
   async function handleSessionCommand(ctx) {
     const { bot, chatId, text } = ctx;
 
@@ -61,7 +77,7 @@ function createSessionCommandHandler(deps) {
         const boundProj = boundKey && newCfg.projects && newCfg.projects[boundKey];
         if (boundProj && boundProj.cwd) {
           const boundCwd = normalizeCwd(boundProj.cwd);
-          const session = createSession(chatId, boundCwd, '');
+          const session = createSession(chatId, boundCwd, '', normalizeEngineName(boundProj.engine));
           await bot.sendMessage(chatId, `✅ 新会话已创建\nWorkdir: ${session.cwd}`);
           return true;
         }
@@ -87,7 +103,13 @@ function createSessionCommandHandler(deps) {
           return true;
         }
       }
-      const session = createSession(chatId, dirPath, sessionName || '');
+      const cfgForEngine = loadConfig();
+      const mapForEngine = { ...(cfgForEngine.telegram ? cfgForEngine.telegram.chat_agent_map : {}), ...(cfgForEngine.feishu ? cfgForEngine.feishu.chat_agent_map : {}) };
+      const mappedKeyForEngine = mapForEngine[String(chatId)];
+      const mappedProjForEngine = mappedKeyForEngine && cfgForEngine.projects ? cfgForEngine.projects[mappedKeyForEngine] : null;
+      const currentEngine = normalizeEngineName(getSession(chatId) && getSession(chatId).engine);
+      const sessionEngine = normalizeEngineName((mappedProjForEngine && mappedProjForEngine.engine) || currentEngine);
+      const session = createSession(chatId, dirPath, sessionName || '', sessionEngine);
       const label = sessionName ? `[${sessionName}]` : '';
       await bot.sendMessage(chatId, `New session ${label}\nWorkdir: ${session.cwd}`);
       return true;
@@ -142,11 +164,15 @@ function createSessionCommandHandler(deps) {
       if (!s) {
         // Last resort: use __continue__ to resume whatever Claude thinks is last
         const state2 = loadState();
+        const cfgForEngine = loadConfig();
+        const currentEngine = normalizeEngineName(state2.sessions[chatId] && state2.sessions[chatId].engine);
+        const engineByCwd = inferEngineByCwd(cfgForEngine, curCwd || HOME);
         state2.sessions[chatId] = {
           id: '__continue__',
           cwd: curCwd || HOME,
           created: new Date().toISOString(),
           started: true,
+          engine: engineByCwd || currentEngine,
         };
         saveState(state2);
         await bot.sendMessage(chatId, `⚡ Resuming last session in ${path.basename(curCwd || HOME)}`);
@@ -154,10 +180,14 @@ function createSessionCommandHandler(deps) {
       }
 
       const state2 = loadState();
+      const cfgForEngine = loadConfig();
+      const currentEngine = normalizeEngineName(state2.sessions[chatId] && state2.sessions[chatId].engine);
+      const engineByCwd = inferEngineByCwd(cfgForEngine, s.projectPath || HOME);
       state2.sessions[chatId] = {
         id: s.sessionId,
         cwd: s.projectPath || HOME,
         started: true,
+        engine: engineByCwd || currentEngine,
       };
       saveState(state2);
       // Display: name/summary + id on separate lines
@@ -223,9 +253,12 @@ function createSessionCommandHandler(deps) {
 
     // /sessions — compact list, tap to see details, then tap to switch
     if (text === '/sessions') {
+      const currentEngine = normalizeEngineName(getSession(chatId) && getSession(chatId).engine);
+      const codexLimitTip = '⚠️ 当前为 Codex 会话：`/sessions` 列表暂仅展示 Claude 本地会话，Codex 会话暂不可见。';
       const allSessions = listRecentSessions(15);
       if (allSessions.length === 0) {
-        await bot.sendMessage(chatId, 'No sessions found. Try /new first.');
+        const base = 'No sessions found. Try /new first.';
+        await bot.sendMessage(chatId, currentEngine === 'codex' ? `${base}\n\n${codexLimitTip}` : base);
         return true;
       }
       if (bot.sendButtons) {
@@ -236,8 +269,12 @@ function createSessionCommandHandler(deps) {
         allSessions.forEach((s, i) => {
           msg += sessionRichLabel(s, i + 1, _tags1) + '\n';
         });
+        if (currentEngine === 'codex') msg += `\n${codexLimitTip}\n`;
         await bot.sendMessage(chatId, msg);
       }
+      if (bot.sendButtons && currentEngine === 'codex') {
+        await bot.sendMessage(chatId, codexLimitTip);
+      }
       return true;
     }
 
@@ -348,10 +385,14 @@ function createSessionCommandHandler(deps) {
           const target = candidates[0];
           // Switch to that session (like /resume) AND its directory
           const state2 = loadState();
+          const cfgForEngine = loadConfig();
+          const currentEngine = normalizeEngineName(state2.sessions[chatId] && state2.sessions[chatId].engine);
+          const engineByCwd = inferEngineByCwd(cfgForEngine, target.projectPath);
           state2.sessions[chatId] = {
             id: target.sessionId,
             cwd: target.projectPath,
             started: true,
+            engine: engineByCwd || currentEngine,
           };
           saveState(state2);
           const name = target.customTitle || target.summary || '';
@@ -378,19 +419,26 @@ function createSessionCommandHandler(deps) {
       if (recentInDir.length > 0 && recentInDir[0].sessionId) {
         // Attach to existing session in this directory
         const target = recentInDir[0];
+        const cfgForEngine = loadConfig();
+        const engineByCwd = inferEngineByCwd(cfgForEngine, newCwd);
         state2.sessions[chatId] = {
           id: target.sessionId,
           cwd: newCwd,
           started: true,
+          engine: engineByCwd || normalizeEngineName(state2.sessions[chatId] && state2.sessions[chatId].engine),
         };
         saveState(state2);
         const label = target.customTitle || target.summary?.slice(0, 30) || target.sessionId.slice(0, 8);
         await bot.sendMessage(chatId, `📁 ${path.basename(newCwd)}\n🔄 Attached: ${label}`);
       } else if (!state2.sessions[chatId]) {
-        createSession(chatId, newCwd);
+        const cfgForEngine = loadConfig();
+        const engineByCwd = inferEngineByCwd(cfgForEngine, newCwd);
+        const currentEngine = normalizeEngineName(getSession(chatId) && getSession(chatId).engine);
+        createSession(chatId, newCwd, '', engineByCwd || currentEngine);
         await bot.sendMessage(chatId, `📁 ${path.basename(newCwd)} (new session)`);
       } else {
         state2.sessions[chatId].cwd = newCwd;
+        if (!state2.sessions[chatId].engine) state2.sessions[chatId].engine = getDefaultEngine();
         saveState(state2);
         await bot.sendMessage(chatId, `📁 ${path.basename(newCwd)}`);
       }

package/scripts/daemon-session-store.js

@@ -432,13 +432,14 @@ function createSessionStore(deps) {
     return state.sessions[chatId] || null;
   }
 
-  function createSession(chatId, cwd, name) {
+  function createSession(chatId, cwd, name, engine = 'claude') {
     const state = loadState();
     const sessionId = crypto.randomUUID();
     state.sessions[chatId] = {
       id: sessionId,
       cwd: cwd || HOME,
       started: false,
+      engine: String(engine || 'claude').trim().toLowerCase() === 'codex' ? 'codex' : 'claude',
     };
     saveState(state);
     invalidateSessionCache();

package/scripts/daemon-task-scheduler.js

@@ -95,6 +95,23 @@ function nextClockRunAfter(schedule, fromMs) {
   return baseMs + 24 * 60 * 60 * 1000;
 }
 
+// Map short aliases and full model IDs to what Claude CLI accepts.
+// Claude CLI 2.x accepts both 'sonnet' and 'claude-sonnet-4-6'.
+// This normalization keeps daemon.yaml configs forward-compatible.
+const MODEL_ALIASES = {
+  haiku: 'claude-haiku-4-5-20251001',
+  sonnet: 'claude-sonnet-4-6',
+  opus: 'claude-opus-4-6',
+};
+
+function normalizeModel(raw) {
+  if (!raw || typeof raw !== 'string') return MODEL_ALIASES.haiku;
+  const lower = raw.trim().toLowerCase();
+  if (Object.prototype.hasOwnProperty.call(MODEL_ALIASES, lower)) return MODEL_ALIASES[lower];
+  // Already a full model ID (e.g. 'claude-sonnet-4-6') — pass through
+  return raw.trim();
+}
+
 function buildTaskSchedule(task, parseInterval) {
   const atRaw = typeof task.at === 'string' ? task.at.trim() : '';
   if (atRaw) {
@@ -195,25 +212,24 @@ function createTaskScheduler(deps) {
     try {
       let cmd = task.precondition;
 
-      // Cross-platform: expand ~ to HOME and handle `test -s` (Unix-only) via Node.js
+      // Cross-platform: expand ~ to HOME and handle `test -s` via Node.js
       cmd = cmd.replace(/^~|(?<=\s)~/g, HOME);
-      if (IS_WIN) {
-        // `test -s <file>` checks file exists and is non-empty — do it in JS
-        const testMatch = cmd.match(/^test\s+-s\s+(.+)$/);
-        if (testMatch) {
-          const filePath = testMatch[1].trim().replace(/["']/g, '');
-          const fs = require('fs');
-          try {
-            const stat = fs.statSync(filePath);
-            if (stat.size > 0) {
-              const content = fs.readFileSync(filePath, 'utf8').trim();
-              log('INFO', `Precondition passed for ${task.name} (${content.split('\n').length} lines)`);
-              return { pass: true, context: content };
-            }
-          } catch { /* file doesn't exist */ }
-          log('INFO', `Precondition failed for ${task.name}: file empty or missing`);
-          return { pass: false, context: '' };
-        }
+      // Handle `test -s <file>` natively in JS on ALL platforms.
+      // Shell `test -s` produces no stdout on success, which previously
+      // caused the empty-output check below to incorrectly skip the task.
+      const testMatch = cmd.match(/^test\s+-s\s+(.+)$/);
+      if (testMatch) {
+        const filePath = testMatch[1].trim().replace(/["']/g, '');
+        const fs = require('fs');
+        try {
+          const content = fs.readFileSync(filePath, 'utf8').trim();
+          if (content.length > 0) {
+            log('INFO', `Precondition passed for ${task.name} (${content.split('\n').length} lines)`);
+            return { pass: true, context: content };
+          }
+        } catch { /* file doesn't exist or unreadable */ }
+        log('INFO', `Precondition failed for ${task.name}: file empty or missing`);
+        return { pass: false, context: '' };
       }
 
       const output = execSync(cmd, {
@@ -358,7 +374,7 @@ function createTaskScheduler(deps) {
     }
 
     const preamble = buildProfilePreamble();
-    const model = task.model || 'haiku';
+    const model = normalizeModel(task.model || 'haiku');
     // If precondition returned context data, append it to the prompt
     let taskPrompt = task.prompt;
     if (precheck.context) {
@@ -533,7 +549,7 @@ function createTaskScheduler(deps) {
     const steps = task.steps || [];
     if (steps.length === 0) return { success: false, error: 'No steps defined', output: '' };
 
-    const model = task.model || 'sonnet';
+    const model = normalizeModel(task.model || 'sonnet');
     const cwd = task.cwd ? task.cwd.replace(/^~/, HOME) : HOME;
     const sessionId = crypto.randomUUID();
     const outputs = [];
@@ -617,11 +633,22 @@ function createTaskScheduler(deps) {
     return found || null;
   }
 
-  function startHeartbeat(config, notifyFn) {
+  function startHeartbeat(config, notifyFn, notifyPersonalFn) {
     const { all: tasks } = getAllTasks(config);
 
     const enabledTasks = tasks.filter(t => t.enabled !== false);
     const checkIntervalSec = (config.daemon && config.daemon.heartbeat_check_interval) || 60;
+
+    // Helper: compute next run time, falling back to 2-tick backoff on error.
+    function safeNextRun(taskName, schedule, now) {
+      try {
+        return { next: nextRunAfter(schedule, now), failed: false };
+      } catch (e) {
+        log('ERROR', `nextRunAfter failed for "${taskName}": ${e.message}`);
+        return { next: now + checkIntervalSec * 2 * 1000, failed: true };
+      }
+    }
+
     const taskSchedules = new Map();
     const runnableTasks = [];
     for (const task of enabledTasks) {
@@ -654,7 +681,25 @@ function createTaskScheduler(deps) {
     // Tracks tasks currently running (prevents concurrent runs of the same task)
     const runningTasks = new Set();
 
+    // Wake detection: if tick interval far exceeds expected, system likely slept (macOS lid close).
+    // Use 5min floor to avoid false triggers from CPU load spikes or GC pauses.
+    let lastTickTime = Date.now();
+    const WAKE_THRESHOLD = Math.max(checkIntervalSec * 3 * 1000, 5 * 60 * 1000);
+
     const timer = setInterval(() => {
+      const tickNow = Date.now();
+      const tickElapsed = tickNow - lastTickTime;
+      lastTickTime = tickNow;
+
+      if (tickElapsed > WAKE_THRESHOLD) {
+        log('FATAL', `[WAKE-DETECT] System resumed after ${Math.round(tickElapsed / 1000)}s sleep — restarting daemon to rebuild connections`);
+        const st = loadState();
+        st.wake_restart = new Date().toISOString();
+        st.wake_sleep_seconds = Math.round(tickElapsed / 1000);
+        saveState(st);
+        process.exit(1); // caffeinate will restart us with fresh connections
+      }
+
       // ① Physiological heartbeat (zero token, pure awareness)
       physiologicalHeartbeat(config);
 
@@ -686,12 +731,14 @@ function createTaskScheduler(deps) {
 
           if (runningTasks.has(task.name)) {
             // Task is still running; skip this cycle and keep full interval cadence.
-            nextRun[task.name] = nextRunAfter(schedule, currentTime);
+            nextRun[task.name] = safeNextRun(task.name, schedule, currentTime).next;
             log('WARN', `Task ${task.name} still running — skipping this interval`);
             continue;
           }
 
-          nextRun[task.name] = nextRunAfter(schedule, currentTime);
+          const { next: nextRunTime, failed: schedFailed } = safeNextRun(task.name, schedule, currentTime);
+          nextRun[task.name] = nextRunTime;
+          if (schedFailed) continue; // back off, skip execution this cycle
           runningTasks.add(task.name);
           // executeTask now returns a Promise (async, non-blocking, process-group kill)
           Promise.resolve(executeTask(task, config))
@@ -714,13 +761,20 @@ function createTaskScheduler(deps) {
       }
 
       // Skill evolution: check queue and notify user of actionable items
-      if (skillEvolution) {
+      // Can be disabled via daemon.yaml: skill_evolution_notify: false
+      const skillEvolutionNotifyEnabled = !config.daemon || config.daemon.skill_evolution_notify !== false;
+      if (skillEvolution && skillEvolutionNotifyEnabled) {
         try {
           const notifications = skillEvolution.checkEvolutionQueue();
           for (const item of notifications) {
             let msg = '';
             const idHint = item.id ? `\nID: \`${item.id}\`` : '';
-            if (item.type === 'skill_gap') {
+            if (item.type === 'workflow_proposal') {
+              msg = `🔄 *工作流技能建议*\n检测到重复工作流: ${item.search_hint || item.reason}`;
+              if (item.tools_signature && item.tools_signature.length) msg += `\n工具: ${item.tools_signature.join(', ')}`;
+              if (item.example_prompt) msg += `\n示例: "${item.example_prompt}"`;
+              if (item.evidence_count) msg += `\n出现次数: ${item.evidence_count}`;
+            } else if (item.type === 'skill_gap') {
               msg = `🧬 *技能缺口检测*\n${item.reason}`;
               if (item.search_hint) msg += `\n搜索建议: \`${item.search_hint}\``;
             } else if (item.type === 'skill_fix') {
@@ -728,9 +782,14 @@ function createTaskScheduler(deps) {
             } else if (item.type === 'user_complaint') {
               msg = `⚠️ *技能反馈*\n技能 \`${item.skill_name}\` 收到用户反馈\n${item.reason}`;
             }
-            if (msg && item.id) msg += `${idHint}\n处理: \`/skill-evo done ${item.id}\` 或 \`/skill-evo dismiss ${item.id}\``;
-            else if (msg) msg += idHint;
-            if (msg && notifyFn) notifyFn(msg);
+            if (msg && item.id && item.type === 'workflow_proposal') {
+              msg += `${idHint}\n处理: \`/skill-evo approve ${item.id}\` 或 \`/skill-evo dismiss ${item.id}\``;
+            } else if (msg && item.id) {
+              msg += `${idHint}\n处理: \`/skill-evo done ${item.id}\` 或 \`/skill-evo dismiss ${item.id}\``;
+            } else if (msg) msg += idHint;
+            // Skill notifications go only to personal chats, not agent group chats
+            const skillNotifyFn = notifyPersonalFn || notifyFn;
+            if (msg && skillNotifyFn) skillNotifyFn(msg);
           }
         } catch (e) { log('WARN', `Skill evolution queue check failed: ${e.message}`); }
       }

package/scripts/daemon-user-acl.js

@@ -166,7 +166,7 @@ const ACTION_GROUPS = {
 const ROLE_DEFAULT_ACTIONS = {
   admin:   Object.keys(ACTION_GROUPS),       // 全部权限
   member:  ['query'],                         // 默认只能问答
-  stranger: [],                               // 无系统权限，但允许基础问答由 askClaude readOnly 处理
+  stranger: ['query'],                        // 仅基础问答（只读）
 };
 
 // 不可赋予 member 的 admin 专属 action
@@ -182,6 +182,7 @@ const ADMIN_ONLY_ACTIONS = new Set(['system', 'agent', 'config', 'admin_acl']);
  */
 function resolveUserCtx(senderId, config) {
   const userData = loadUsers();
+  const hasConfiguredUsers = !!(userData && userData.users && Object.keys(userData.users).length > 0);
 
   let role, name, allowedActions;
 
@@ -213,9 +214,25 @@ function resolveUserCtx(senderId, config) {
         name = senderId.slice(-6);
         allowedActions = ROLE_DEFAULT_ACTIONS.admin;
       } else {
-        role = userData.default_role || 'stranger';
-        name = senderId.slice(-6);
-        allowedActions = ROLE_DEFAULT_ACTIONS[role] || [];
+        if (!hasConfiguredUsers) {
+          // Bootstrap only once: persist the first seen sender as admin.
+          const next = {
+            default_role: userData.default_role || 'stranger',
+            users: { ...(userData.users || {}) },
+          };
+          next.users[senderId] = {
+            role: 'admin',
+            name: senderId.slice(-6),
+          };
+          try { saveUsers(next); } catch { /* non-fatal: fallback to in-memory role */ }
+          role = 'admin';
+          name = senderId.slice(-6);
+          allowedActions = ROLE_DEFAULT_ACTIONS.admin;
+        } else {
+          role = userData.default_role || 'stranger';
+          name = senderId.slice(-6);
+          allowedActions = ROLE_DEFAULT_ACTIONS[role] || [];
+        }
       }
     }
   }
@@ -313,7 +330,7 @@ function handleUserCommand(text, userCtx) {
 
   if (sub === 'add') {
     // /user add <open_id> <role> [name...]
-    const [, , , uid, role, ...nameParts] = args;
+    const [, , uid, role, ...nameParts] = args;
     if (!uid || !role) return { handled: true, reply: '用法: /user add <open_id> <role> [name]' };
     // [S2] open_id 格式校验
     if (!isValidOpenId(uid)) return { handled: true, reply: '❌ open_id 格式不合法（应为 10-64 位字母数字下划线）' };
@@ -328,7 +345,7 @@ function handleUserCommand(text, userCtx) {
   }
 
   if (sub === 'role') {
-    const [, , , uid, role] = args;
+    const [, , uid, role] = args;
     if (!uid || !role) return { handled: true, reply: '用法: /user role <open_id> <role>' };
     if (!isValidOpenId(uid)) return { handled: true, reply: '❌ open_id 格式不合法' };
     if (!['admin', 'member', 'stranger'].includes(role)) {
@@ -343,7 +360,7 @@ function handleUserCommand(text, userCtx) {
   }
 
   if (sub === 'grant') {
-    const [, , , uid, action] = args;
+    const [, , uid, action] = args;
     if (!uid || !action) return { handled: true, reply: '用法: /user grant <open_id> <action>' };
     if (!isValidOpenId(uid)) return { handled: true, reply: '❌ open_id 格式不合法' };
     if (ADMIN_ONLY_ACTIONS.has(action)) {
@@ -364,7 +381,7 @@ function handleUserCommand(text, userCtx) {
   }
 
   if (sub === 'revoke') {
-    const [, , , uid, action] = args;
+    const [, , uid, action] = args;
     if (!uid || !action) return { handled: true, reply: '用法: /user revoke <open_id> <action>' };
     if (!isValidOpenId(uid)) return { handled: true, reply: '❌ open_id 格式不合法' };
     const data = loadUsers();
@@ -376,7 +393,7 @@ function handleUserCommand(text, userCtx) {
   }
 
   if (sub === 'remove') {
-    const [, , , uid] = args;
+    const [, , uid] = args;
     if (!uid) return { handled: true, reply: '用法: /user remove <open_id>' };
     if (!isValidOpenId(uid)) return { handled: true, reply: '❌ open_id 格式不合法' };
     const data = loadUsers();

package/scripts/daemon.js

@@ -144,6 +144,7 @@ const { createFileBrowser } = require('./daemon-file-browser');
 const { createPidManager, setupRuntimeWatchers } = require('./daemon-runtime-lifecycle');
 const { createNotifier } = require('./daemon-notify');
 const { createClaudeEngine } = require('./daemon-claude-engine');
+const { createEngineRuntimeFactory, detectDefaultEngine, ENGINE_DISTILL_MAP } = require('./daemon-engine-runtime');
 const { createCommandRouter } = require('./daemon-command-router');
 const { createTaskScheduler } = require('./daemon-task-scheduler');
 const { createAgentTools } = require('./daemon-agent-tools');
@@ -932,6 +933,15 @@ function handleDispatchItem(item, config) {
     log('WARN', `dispatch: unknown target "${item.target}"`);
     return;
   }
+  // 安全护栏：禁止 agent 主动 dispatch 到 personal（防止 LLM 幻觉乱发消息给小美）
+  // personal 只允许用户本人触发，或来源为 user/unknown 的系统任务
+  const _agentSources = new Set(Object.keys((config.projects) || {}));
+  const isFromAgent = _agentSources.has(item.from) || item.from === '_claude_session';
+  const targetProject = config.projects?.[item.target] || {};
+  if (isFromAgent && targetProject.guard === 'user-only') {
+    log('WARN', `dispatch: blocked agent "${item.from}" → "${item.target}" (user-only guard)`);
+    return;
+  }
   log('INFO', `Dispatch: ${item.from || '?'} → ${item.target}: ${item.prompt.slice(0, 60)}`);
   let pendingReplyFn = null;
   let streamOptions = null;
@@ -1109,13 +1119,11 @@ const {
 /**
  * Attach chatId to the most recent session in projCwd, or create a new one.
  */
-function attachOrCreateSession(chatId, projCwd, name) {
-  const state = loadState();
+function attachOrCreateSession(chatId, projCwd, name, engine) {
+  engine = engine || getDefaultEngine();
   // Virtual chatIds (_agent_* / _scope_*) are isolated from real user chats.
   // This avoids cross-context session collisions between user chat and dispatch flows.
-  const newSess = createSession(chatId, projCwd, name || '');
-  state.sessions[chatId] = { id: newSess.id, cwd: projCwd, started: false };
-  saveState(state);
+  createSession(chatId, projCwd, name || '', engine);
 }
 
 /**
@@ -1264,7 +1272,7 @@ const {
 watchSessionFiles(); // 热加载：手机端新建 session 后桌面无需重启
 
 // Active Claude processes per chat (for /stop)
-const activeProcesses = new Map(); // chatId -> { child, aborted }
+const activeProcesses = new Map(); // chatId -> { child, aborted, engine, killSignal }
 
 // Activity tracking for idle/sleep detection
 let lastInteractionTime = Date.now(); // updated on every incoming message
@@ -1301,13 +1309,19 @@ function isUserIdle() {
   return activeProcesses.size === 0;
 }
 
-// Fix3: persist child PIDs so next daemon startup can kill orphans
-const ACTIVE_PIDS_FILE = path.join(HOME, '.metame', 'active_claude_pids.json');
+// Persist child PIDs so next daemon startup can kill orphans
+const ACTIVE_PIDS_FILE = path.join(HOME, '.metame', 'active_agent_pids.json');
 function saveActivePids() {
   try {
     const pids = {};
     for (const [chatId, proc] of activeProcesses) {
-      if (proc.child && proc.child.pid) pids[chatId] = proc.child.pid;
+      if (proc.child && proc.child.pid) {
+        pids[chatId] = {
+          pid: proc.child.pid,
+          engine: proc.engine || getDefaultEngine(),
+          killSignal: proc.killSignal || 'SIGTERM',
+        };
+      }
     }
     fs.writeFileSync(ACTIVE_PIDS_FILE, JSON.stringify(pids), 'utf8');
   } catch { }
@@ -1321,22 +1335,63 @@ function killOrphanPids() {
   try {
     if (!fs.existsSync(ACTIVE_PIDS_FILE)) return;
     const pids = JSON.parse(fs.readFileSync(ACTIVE_PIDS_FILE, 'utf8'));
-    for (const [chatId, pid] of Object.entries(pids)) {
+    for (const [chatId, rec] of Object.entries(pids)) {
       try {
-        // Safety: only kill if PID still belongs to a claude process (prevent PID reuse accidents)
+        const pid = typeof rec === 'number' ? rec : Number(rec && rec.pid);
+        if (!Number.isFinite(pid) || pid <= 0) continue;
+        // Safety: only kill if PID still belongs to a known agent process (prevent PID reuse accidents)
         const comm = getProcessName(pid);
-        if (!comm || !comm.includes('claude')) {
-          log('WARN', `Skipping PID ${pid} (chatId: ${chatId}): process is "${comm}", not claude`);
+        const isKnownAgent = !!comm && (comm.includes('claude') || comm.includes('codex'));
+        if (!isKnownAgent) {
+          log('WARN', `Skipping PID ${pid} (chatId: ${chatId}): process is "${comm}", not claude/codex`);
           continue;
         }
         process.kill(pid, 'SIGKILL');
-        log('INFO', `Killed orphan claude PID ${pid} (chatId: ${chatId})`);
+        log('INFO', `Killed orphan agent PID ${pid} (chatId: ${chatId})`);
       } catch { }
     }
     fs.unlinkSync(ACTIVE_PIDS_FILE);
   } catch { }
 }
 
+const detectedEngine = detectDefaultEngine({ fs, execSync });
+let _defaultEngine = loadState().default_engine || detectedEngine;
+if (providerMod && typeof providerMod.setEngine === 'function') {
+  providerMod.setEngine(_defaultEngine);
+}
+log('INFO', `Default engine: ${_defaultEngine} (detected: ${detectedEngine})`);
+
+function getDefaultEngine() {
+  return _defaultEngine;
+}
+
+function setDefaultEngine(engine) {
+  _defaultEngine = engine;
+  const st = loadState();
+  st.default_engine = engine;
+  saveState(st);
+  if (providerMod) {
+    // Couple distill model
+    if (typeof providerMod.setDistillModel === 'function') {
+      const paired = ENGINE_DISTILL_MAP[engine] || ENGINE_DISTILL_MAP.claude;
+      try { providerMod.setDistillModel(paired); } catch { /* ignore */ }
+    }
+    // Couple distill binary
+    if (typeof providerMod.setEngine === 'function') {
+      try { providerMod.setEngine(engine); } catch { /* ignore */ }
+    }
+  }
+}
+
+const getEngineRuntime = createEngineRuntimeFactory({
+  fs,
+  path,
+  HOME,
+  execSync,
+  CLAUDE_BIN,
+  getActiveProviderEnv,
+});
+
 const {
   checkPrecondition,
   executeTask,
@@ -1403,6 +1458,8 @@ const { handleAdminCommand } = createAdminCommandHandler({
   getMessageQueue: () => messageQueue,
   loadState,
   saveState,
+  getDefaultEngine,
+  setDefaultEngine,
 });
 
 const { handleSessionCommand } = createSessionCommandHandler({
@@ -1430,6 +1487,7 @@ const { handleSessionCommand } = createSessionCommandHandler({
   sessionRichLabel,
   buildSessionCardElements,
   sessionLabel,
+  getDefaultEngine,
 });
 
 // Message queue for messages received while a task is running
@@ -1472,6 +1530,8 @@ const { spawnClaudeAsync, askClaude } = createClaudeEngine({
   touchInteraction,
   statusThrottleMs: STATUS_THROTTLE_MS,
   fallbackThrottleMs: FALLBACK_THROTTLE_MS,
+  getEngineRuntime,
+  getDefaultEngine,
 });
 
 const agentTools = createAgentTools({
@@ -1531,6 +1591,7 @@ const { handleAgentCommand } = createAgentCommandHandler({
   attachOrCreateSession,
   agentFlowTtlMs: getAgentFlowTtlMs,
   agentBindTtlMs: getAgentBindTtlMs,
+  getDefaultEngine,
 });
 
 // Caffeinate process for /nosleep toggle (macOS only)
@@ -1604,6 +1665,7 @@ const { handleCommand } = createCommandRouter({
   pendingAgentFlows,
   pendingActivations,
   agentFlowTtlMs: getAgentFlowTtlMs,
+  getDefaultEngine,
 });
 
 // Bind handleCommand for agent dispatch (must come after handleCommand definition)
@@ -1749,12 +1811,13 @@ async function main() {
   });
   const notifyFn = notifier.notify;
   const adminNotifyFn = notifier.notifyAdmin;
+  const notifyPersonalFn = notifier.notifyPersonal;
 
   // Start dispatch socket server (low-latency IPC, fallback: file polling still works)
   const dispatchSocket = startDispatchSocket(() => config);
 
   // Start heartbeat scheduler
-  let heartbeatTimer = startHeartbeat(config, notifyFn);
+  let heartbeatTimer = startHeartbeat(config, notifyFn, notifyPersonalFn);
 
   const runtimeWatchers = setupRuntimeWatchers({
     fs,
@@ -1769,6 +1832,7 @@ async function main() {
     log,
     notifyFn,
     adminNotifyFn,
+    notifyPersonalFn,
     activeProcesses,
     getConfig: () => config,
     setConfig: (next) => { config = next; },
@@ -1819,10 +1883,10 @@ async function main() {
     if (feishuBridge) feishuBridge.stop();
     // Stop QMD semantic search daemon if it was started
     try { require('./qmd-client').stopDaemon(); } catch { /* ignore */ }
-    // Kill all tracked claude process groups before exiting (covers sub-agents too)
+    // Kill all tracked engine process groups before exiting (covers sub-agents too)
     for (const [cid, proc] of activeProcesses) {
       try { process.kill(-proc.child.pid, 'SIGKILL'); } catch { try { proc.child.kill('SIGKILL'); } catch { } }
-      log('INFO', `Shutdown: killed claude process group for chatId ${cid}`);
+      log('INFO', `Shutdown: killed engine process group for chatId ${cid}`);
     }
     activeProcesses.clear();
     try { if (fs.existsSync(ACTIVE_PIDS_FILE)) fs.unlinkSync(ACTIVE_PIDS_FILE); } catch { }