metame-cli 1.4.34 → 1.5.1

package/scripts/daemon-command-router.js

@@ -26,6 +26,7 @@ function createCommandRouter(deps) {
     pendingAgentFlows,
     pendingActivations,
     agentFlowTtlMs,
+    getDefaultEngine,
   } = deps;
 
   function resolveFlowTtlMs() {
@@ -154,8 +155,8 @@ function createCommandRouter(deps) {
     const explicit = extractAgentName(input);
     if (explicit) return explicit;
     if (workspaceDir) {
-      const segs = workspaceDir.split('/').filter(Boolean);
-      if (segs.length > 0) return segs[segs.length - 1];
+      const basename = workspaceDir.split(/[/\\]/).filter(Boolean).pop();
+      if (basename) return basename;
     }
     return 'workspace-agent';
   }
@@ -178,6 +179,13 @@ function createCommandRouter(deps) {
     return '';
   }
 
+  function inferAgentEngineFromText(input) {
+    const text = String(input || '').trim().toLowerCase();
+    if (!text) return null;
+    if (/\bcodex\b/.test(text) || /柯德|科德/.test(text)) return 'codex';
+    return null;
+  }
+
   function isLikelyDirectAgentAction(input) {
     const text = String(input || '').trim();
     return /^(?:请|帮我|麻烦|给我|给这个群|给当前群|在这个群|把这个群|把当前群|将这个群|这个群|当前群|本群|群里|我想|我要|我需要|创建|新建|新增|搞一个|加一个|create|bind|绑定|列出|查看|显示|有哪些|解绑|取消绑定|断开绑定|修改|调整)/i.test(text);
@@ -414,6 +422,10 @@ function createCommandRouter(deps) {
         await bot.sendMessage(chatId, '❌ 当前群未绑定 Agent。先说“给这个群绑定一个 Agent，目录是 ~/xxx”。');
         return true;
       }
+      // Lazy migration: ensure soul layer exists for agents created before this feature
+      if (agentTools && typeof agentTools.repairAgentSoul === 'function') {
+        await agentTools.repairAgentSoul(bound.project.cwd).catch(() => {});
+      }
       const roleDelta = deriveRoleDelta(input);
       const res = await agentTools.editAgentRoleDefinition(bound.project.cwd, roleDelta);
       if (!res.ok) {
@@ -435,14 +447,19 @@ function createCommandRouter(deps) {
       }
       const agentName = deriveAgentName(input, workspaceDir);
       const roleDelta = deriveCreateRoleDelta(input);
+      const inferredEngine = inferAgentEngineFromText(input);
       // Always skip binding creating chat — new group activates via /activate
-      const res = await agentTools.createNewWorkspaceAgent(agentName, workspaceDir, roleDelta, chatId, { skipChatBinding: true });
+      const res = await agentTools.createNewWorkspaceAgent(agentName, workspaceDir, roleDelta, chatId, {
+        skipChatBinding: true,
+        engine: inferredEngine,
+      });
       if (!res.ok) {
         await bot.sendMessage(chatId, `❌ 创建 Agent 失败: ${res.error}`);
         return true;
       }
       const data = res.data || {};
       const projName = projectNameFromResult(data, agentName);
+      const engineTip = data.project && data.project.engine ? `\n引擎: ${data.project.engine}` : '';
       if (data.projectKey && pendingActivations) {
         pendingActivations.set(data.projectKey, {
           agentKey: data.projectKey, agentName: projName, cwd: data.cwd,
@@ -450,7 +467,7 @@ function createCommandRouter(deps) {
         });
       }
       await bot.sendMessage(chatId,
-        `✅ Agent「${projName}」已创建\n目录: ${data.cwd || '（未知）'}\n\n` +
+        `✅ Agent「${projName}」已创建\n目录: ${data.cwd || '（未知）'}${engineTip}\n\n` +
         `**下一步**: 在新群里发送 \`/activate\` 完成绑定（30分钟内有效）`
       );
       return true;
@@ -458,14 +475,15 @@ function createCommandRouter(deps) {
 
     if (wantsBind) {
       const agentName = deriveAgentName(input, workspaceDir);
-      const res = await agentTools.bindAgentToChat(chatId, agentName, workspaceDir || null);
+      const inferredEngine = inferAgentEngineFromText(input);
+      const res = await agentTools.bindAgentToChat(chatId, agentName, workspaceDir || null, { engine: inferredEngine });
       if (!res.ok) {
         await bot.sendMessage(chatId, `❌ 绑定失败: ${res.error}`);
         return true;
       }
       const data = res.data || {};
       const projName = projectNameFromResult(data, agentName);
-      if (data.cwd) attachOrCreateSession(chatId, normalizeCwd(data.cwd), projName);
+      if (data.cwd) attachOrCreateSession(chatId, normalizeCwd(data.cwd), projName, (data.project && data.project.engine) || getDefaultEngine());
       await bot.sendMessage(chatId, `✅ 已绑定 Agent\n名称: ${projName}\n目录: ${data.cwd || '（未知）'}`);
       return true;
     }
@@ -504,8 +522,10 @@ function createCommandRouter(deps) {
       const proj = config.projects[mappedKey];
       const projCwd = normalizeCwd(proj.cwd);
       const cur = loadState().sessions?.[chatId];
-      if (!cur || cur.cwd !== projCwd) {
-        attachOrCreateSession(chatId, projCwd, proj.name || mappedKey);
+      const curEngine = String((cur && cur.engine) || getDefaultEngine()).toLowerCase();
+      const projEngine = String((proj && proj.engine) || getDefaultEngine()).toLowerCase();
+      if (!cur || cur.cwd !== projCwd || curEngine !== projEngine) {
+        attachOrCreateSession(chatId, projCwd, proj.name || mappedKey, proj.engine || getDefaultEngine());
       }
     }
 
@@ -551,6 +571,7 @@ function createCommandRouter(deps) {
         '/agent edit — 编辑当前 Agent 角色',
         '/agent unbind — 解绑当前群',
         '/agent reset — 重置当前 Agent 角色',
+        '/agent soul [repair] — 查看/修复 Agent Soul 身份层',
         '',
         '📂 Session 管理:',
         '/new [path] [name] — 新建会话',
@@ -564,7 +585,7 @@ function createCommandRouter(deps) {
         '/undo <hash> — 回退到指定 git checkpoint',
         '/quit — 结束会话，重新加载 MCP/配置',
         '',
-        `⚙️ /model [${currentModel}] /provider [${currentProvider}] /status /tasks /run /budget /reload`,
+        `⚙️ /model [${currentModel}] /engine [${getDefaultEngine()}] /provider [${currentProvider}] /distill-model /status /tasks /run /budget /reload /mentor`,
         '🧩 /TeamTask create <agent> <目标> [--scope <id>] · /TeamTask · /TeamTask <id>',
         '🧠 /memory — 记忆统计 · /memory <关键词> — 搜索事实',
         '🧬 /skill-evo — 查看/处理技能演化队列',
@@ -604,7 +625,7 @@ function createCommandRouter(deps) {
       if (quickAgent && !quickAgent.rest) {
         const { key, proj } = quickAgent;
         const projCwd = normalizeCwd(proj.cwd);
-        attachOrCreateSession(chatId, projCwd, proj.name || key);
+        attachOrCreateSession(chatId, projCwd, proj.name || key, proj.engine || getDefaultEngine());
         log('INFO', `Agent switch via nickname: ${key} (${projCwd})`);
         await bot.sendMessage(chatId, `${proj.icon || '🤖'} ${proj.name || key} 在线`);
         return;

package/scripts/daemon-default.yaml

@@ -33,22 +33,31 @@ projects:
 
 heartbeat:
   tasks:
-    # 认知蒸馏：有偏好信号才触发，4小时冷却，仅在用户闲置时执行
+    # 认知蒸馏：有偏好信号才触发，2小时冷却，仅在用户闲置时执行
     - name: cognitive-distill
       type: script
       command: node ~/.metame/distill.js
-      interval: 4h
+      interval: 2h
       precondition: "test -s ~/.metame/raw_signals.jsonl"
       require_idle: true
       notify: false
       enabled: true
 
-    # 记忆提取：扫描未分析 session，提取长期事实和会话标签，4小时冷却（与 cognitive-distill 对齐）
+    # 记忆提取：扫描未分析 session，提取长期事实和会话标签，4小时冷却
     - name: memory-extract
       type: script
       command: node ~/.metame/memory-extract.js
       interval: 4h
-      timeout: 600
+      timeout: 1800
+      require_idle: true
+      notify: false
+      enabled: true
+
+    # 记忆垃圾回收：每天 02:00 清理过期/重复记忆
+    - name: memory-gc
+      type: script
+      command: node ~/.metame/memory-gc.js
+      at: "02:00"
       require_idle: true
       notify: false
       enabled: true
@@ -63,6 +72,15 @@ heartbeat:
       notify: false
       enabled: true
 
+    # 自我反思：每天 23:00 扫描纠错信号，提炼成长模式
+    - name: self-reflect
+      type: script
+      command: node ~/.metame/self-reflect.js
+      at: "23:00"
+      require_idle: true
+      notify: false
+      enabled: true
+
     # 夜间记忆蒸馏：每天 01:00 提炼热区事实为决策与经验文档
     - name: nightly-reflect
       type: script
@@ -134,3 +152,9 @@ daemon:
   # Mobile users can't click "allow" — so we pre-authorize everything.
   # Security relies on allowed_chat_ids whitelist, not tool restrictions.
   dangerously_skip_permissions: true
+  mentor:
+    enabled: false
+    friction_level: 3
+    mode: gentle
+    exclude_agents: [personal, xianyu]
+    emotion_keywords_extra: []

package/scripts/daemon-engine-runtime.js

@@ -0,0 +1,328 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const CODEX_TOOL_MAP = Object.freeze({
+  command_execution: 'Bash',
+  file_change: 'Write',
+  file_read: 'Read',
+  mcp_tool_call: 'MCP',
+  web_search: 'WebSearch',
+  web_fetch: 'WebFetch',
+});
+
+function normalizeEngineName(name) {
+  const text = String(name || '').trim().toLowerCase();
+  return text === 'codex' ? 'codex' : 'claude';
+}
+
+function resolveBinary(engineName, deps = {}) {
+  const engine = normalizeEngineName(engineName);
+  const home = deps.HOME || os.homedir();
+  const fsMod = deps.fs || fs;
+  const pathMod = deps.path || path;
+  const execSyncFn = deps.execSync || execSync;
+
+  const key = engine === 'codex' ? 'codex' : 'claude';
+  const cmd = process.platform === 'win32' ? `where ${key}` : `which ${key} 2>/dev/null`;
+  try {
+    const lines = execSyncFn(cmd, { encoding: 'utf8', timeout: 3000, ...(process.platform === 'win32' ? { windowsHide: true } : {}) })
+      .split('\n').map(l => l.trim()).filter(Boolean);
+    // On Windows prefer .cmd wrapper (reliably executable by spawn)
+    const preferred = process.platform === 'win32'
+      ? (lines.find(l => l.toLowerCase().endsWith(`${key}.cmd`)) || lines[0])
+      : lines[0];
+    if (preferred) return preferred;
+  } catch { /* fallback */ }
+
+  const candidates = engine === 'codex'
+    ? [
+      pathMod.join(home, '.local', 'bin', 'codex'),
+      '/usr/local/bin/codex',
+      '/opt/homebrew/bin/codex',
+    ]
+    : [
+      pathMod.join(home, '.local', 'bin', 'claude'),
+      pathMod.join(home, '.npm-global', 'bin', 'claude'),
+      '/usr/local/bin/claude',
+      '/opt/homebrew/bin/claude',
+    ];
+  for (const p of candidates) {
+    if (fsMod.existsSync(p)) return p;
+  }
+  return key;
+}
+
+// Single source of truth for all per-engine model config.
+// All other code should read from here — no scattered hardcodes.
+const ENGINE_MODEL_CONFIG = Object.freeze({
+  claude: {
+    main:     'sonnet',                       // default session model
+    distill:  'haiku',                        // background/cheap tasks
+    options:  [                               // /model button list
+      { value: 'opus',   label: 'opus · 最强' },
+      { value: 'sonnet', label: 'sonnet · 均衡' },
+      { value: 'haiku',  label: 'haiku · 轻量' },
+    ],
+    provider: 'anthropic',
+    hint:     null,
+  },
+  codex: {
+    main:     'gpt-5.4',           // recommended for most tasks (official default)
+    distill:  'gpt-5.1-codex-mini', // cost-effective mini
+    options:  [                     // quick-pick buttons (official model names)
+      { value: 'gpt-5.4',            label: 'gpt-5.4 · 推荐' },
+      { value: 'gpt-5.3-codex',      label: 'gpt-5.3-codex · 最新 Codex 专用' },
+      { value: 'gpt-5.1-codex-max',  label: 'gpt-5.1-codex-max · 长任务' },
+      { value: 'gpt-5.1-codex-mini', label: 'gpt-5.1-codex-mini · 轻量' },
+    ],
+    provider: 'openai',
+    hint:     '或直接发送任意 OpenAI 模型名切换',
+  },
+});
+
+// Backward-compat aliases (derived, do not edit directly)
+const ENGINE_DISTILL_MAP = Object.freeze(
+  Object.fromEntries(Object.entries(ENGINE_MODEL_CONFIG).map(([k, v]) => [k, v.distill]))
+);
+const ENGINE_DEFAULT_MODEL = Object.freeze(
+  Object.fromEntries(Object.entries(ENGINE_MODEL_CONFIG).map(([k, v]) => [k, v.main]))
+);
+
+function detectDefaultEngine(deps = {}) {
+  for (const engine of ['claude', 'codex']) {
+    const bin = resolveBinary(engine, deps);
+    if (bin !== engine) return engine; // resolveBinary found a real path
+  }
+  return 'claude'; // ultimate fallback
+}
+
+function classifyEngineError(text) {
+  const msg = String(text || '').trim();
+  if (!msg) return null;
+  if (/(auth|unauthorized|login|api key|authentication|permission denied|forbidden|401|403)/i.test(msg)) {
+    return {
+      code: 'AUTH_REQUIRED',
+      message: '认证失败，请先执行 `codex login`（或配置 OPENAI_API_KEY）后重试。',
+    };
+  }
+  if (/(rate.?limit|too many requests|quota|429)/i.test(msg)) {
+    return {
+      code: 'RATE_LIMIT',
+      message: '请求频率或配额受限，请稍后重试。',
+    };
+  }
+  return {
+    code: 'EXEC_FAILURE',
+    message: msg,
+  };
+}
+
+function parseJsonLine(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+
+function parseClaudeStreamEvent(line) {
+  const raw = parseJsonLine(line);
+  if (!raw || typeof raw !== 'object') return [];
+
+  const out = [];
+  if (raw.type === 'assistant' && raw.message && Array.isArray(raw.message.content)) {
+    for (const block of raw.message.content) {
+      if (!block) continue;
+      if (block.type === 'text' && block.text) {
+        out.push({ type: 'text', text: String(block.text), raw });
+      } else if (block.type === 'tool_use') {
+        out.push({
+          type: 'tool_use',
+          toolName: block.name || 'Tool',
+          toolInput: block.input || {},
+          raw,
+        });
+      }
+    }
+  }
+  if (raw.type === 'system' && raw.subtype === 'init' && raw.session_id) {
+    out.push({ type: 'session', sessionId: String(raw.session_id), raw });
+  }
+  if (raw.type === 'result') {
+    if (raw.session_id) out.push({ type: 'session', sessionId: String(raw.session_id), raw });
+    if (raw.result) out.push({ type: 'text', text: String(raw.result), raw });
+    out.push({ type: 'done', usage: raw.usage || null, raw });
+  }
+  if (raw.type === 'content_block_start' || raw.type === 'content_block_delta') {
+    out.push({ type: 'tool_result', raw });
+  }
+  if (raw.type === 'error') {
+    const classified = classifyEngineError(raw.error || raw.message || '');
+    if (classified) out.push({ type: 'error', ...classified, raw });
+  }
+  return out;
+}
+
+function parseCodexStreamEvent(line) {
+  const raw = parseJsonLine(line);
+  if (!raw || typeof raw !== 'object') return [];
+
+  const out = [];
+  if (raw.type === 'thread.started' && raw.thread_id) {
+    out.push({ type: 'session', sessionId: String(raw.thread_id), raw });
+  }
+
+  if ((raw.type === 'item.started' || raw.type === 'item.completed') && raw.item && raw.item.type) {
+    const itemType = String(raw.item.type);
+    const mapped = CODEX_TOOL_MAP[itemType] || itemType;
+    if (mapped && mapped !== 'reasoning' && itemType !== 'agent_message') {
+      if (raw.type === 'item.started') {
+        out.push({
+          type: 'tool_use',
+          toolName: mapped,
+          toolInput: {
+            command: raw.item.command || '',
+            file_path: raw.item.path || raw.item.file_path || '',
+          },
+          raw,
+        });
+      } else {
+        out.push({ type: 'tool_result', toolName: mapped, raw });
+      }
+    }
+    if (raw.type === 'item.completed' && itemType === 'agent_message' && raw.item.text) {
+      out.push({ type: 'text', text: String(raw.item.text), raw });
+    }
+  }
+
+  if (raw.type === 'turn.completed') {
+    out.push({ type: 'done', usage: raw.usage || null, raw });
+  }
+  if (raw.type === 'error') {
+    const classified = classifyEngineError(raw.error || raw.message || '');
+    if (classified) out.push({ type: 'error', ...classified, raw });
+  }
+  return out;
+}
+
+function buildClaudeArgs(options = {}) {
+  const { model = ENGINE_MODEL_CONFIG.claude.main, readOnly = false, daemonCfg = {}, session = {} } = options;
+  const args = ['-p', '--model', model];
+  if (readOnly) {
+    const readOnlyTools = ['Read', 'Glob', 'Grep', 'WebSearch', 'WebFetch', 'Task'];
+    for (const tool of readOnlyTools) args.push('--allowedTools', tool);
+  } else {
+    // Always bypass permission prompts — desktop users run in trusted local context,
+    // mobile users cannot click dialogs. Security relies on allowed_chat_ids whitelist.
+    args.push('--dangerously-skip-permissions');
+  }
+
+  if (session.id === '__continue__') {
+    args.push('--continue');
+  } else if (session.started && session.id) {
+    args.push('--resume', session.id);
+  } else if (session.id) {
+    args.push('--session-id', session.id);
+  }
+  return args;
+}
+
+function buildCodexArgs(options = {}) {
+  const { model = ENGINE_MODEL_CONFIG.codex.main, readOnly = false, daemonCfg = {}, session = {}, cwd } = options;
+  const isResume = (session && session.started && session.id && session.id !== '__continue__');
+  const args = isResume
+    ? ['exec', 'resume', session.id]
+    : ['exec'];
+
+  args.push('--json', '--skip-git-repo-check');
+  if (model) args.push('-m', model);
+  // -C (cwd) is only supported on fresh exec, not resume
+  if (cwd && !isResume) args.push('-C', cwd);
+
+  // Permission flags are only valid on fresh exec, not resume.
+  // `codex exec resume` does not accept -s or --dangerously-bypass-approvals-and-sandbox.
+  if (!isResume) {
+    if (readOnly) {
+      args.push('-s', 'read-only');
+    } else {
+      // Mobile sessions: user cannot click permission dialogs.
+      // Security relies on allowed_chat_ids whitelist, not tool restrictions.
+      args.push('--dangerously-bypass-approvals-and-sandbox');
+    }
+  }
+
+  // "-" means prompt is read from stdin.
+  args.push('-');
+  return args;
+}
+
+function createEngineRuntimeFactory(deps = {}) {
+  const home = deps.HOME || os.homedir();
+  const claudeBin = deps.CLAUDE_BIN || resolveBinary('claude', { ...deps, HOME: home });
+  const codexBin = deps.CODEX_BIN || resolveBinary('codex', { ...deps, HOME: home });
+  const getActiveProviderEnv = typeof deps.getActiveProviderEnv === 'function'
+    ? deps.getActiveProviderEnv
+    : (() => ({}));
+
+  return function getEngineRuntime(engineName) {
+    const engine = normalizeEngineName(engineName);
+    if (engine === 'codex') {
+      return {
+        name: 'codex',
+        binary: codexBin,
+        defaultModel: ENGINE_MODEL_CONFIG.codex.main,
+        stdinBehavior: 'write-and-close',
+        killSignal: 'SIGTERM',
+        timeouts: { idleMs: 10 * 60 * 1000, toolMs: 25 * 60 * 1000, ceilingMs: 60 * 60 * 1000 },
+        buildArgs: buildCodexArgs,
+        buildEnv: ({ metameProject = '' } = {}) => {
+          const env = { ...process.env, METAME_PROJECT: metameProject };
+          // Unset CODEX_HOME if it points to a non-existent path (corrupted env var)
+          if (env.CODEX_HOME && !fs.existsSync(env.CODEX_HOME)) delete env.CODEX_HOME;
+          return env;
+        },
+        parseStreamEvent: parseCodexStreamEvent,
+        classifyError: classifyEngineError,
+      };
+    }
+    return {
+      name: 'claude',
+      binary: claudeBin,
+      defaultModel: ENGINE_MODEL_CONFIG.claude.main,
+      stdinBehavior: 'write-and-close',
+      killSignal: 'SIGTERM',
+      timeouts: { idleMs: 5 * 60 * 1000, toolMs: 25 * 60 * 1000, ceilingMs: 60 * 60 * 1000 },
+      buildArgs: buildClaudeArgs,
+      buildEnv: ({ metameProject = '' } = {}) => ({
+        ...(() => {
+          const env = { ...process.env, ...getActiveProviderEnv(), METAME_PROJECT: metameProject };
+          delete env.CLAUDECODE;
+          return env;
+        })(),
+      }),
+      parseStreamEvent: parseClaudeStreamEvent,
+      classifyError: classifyEngineError,
+    };
+  };
+}
+
+module.exports = {
+  createEngineRuntimeFactory,
+  normalizeEngineName,
+  resolveBinary,
+  detectDefaultEngine,
+  ENGINE_MODEL_CONFIG,
+  ENGINE_DISTILL_MAP,
+  ENGINE_DEFAULT_MODEL,
+  _private: {
+    classifyEngineError,
+    parseClaudeStreamEvent,
+    parseCodexStreamEvent,
+    buildClaudeArgs,
+    buildCodexArgs,
+  },
+};

package/scripts/daemon-exec-commands.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { classifyTaskUsage } = require('./usage-classifier');
+const { normalizeModel } = require('./daemon-task-scheduler');
 
 function createExecCommandHandler(deps) {
   const {
@@ -23,6 +24,7 @@ function createExecCommandHandler(deps) {
     createSession,
     findSessionFile,
     loadConfig,
+    getDistillModel,
   } = deps;
 
   function truncateOutput(output, maxLen = 4000) {
@@ -178,7 +180,7 @@ function createExecCommandHandler(deps) {
       let taskPrompt = task.prompt;
       if (precheck.context) taskPrompt += `\n\n以下是相关原始数据:\n\`\`\`\n${precheck.context}\n\`\`\``;
       const fullPrompt = preamble + taskPrompt;
-      const model = task.model || 'haiku';
+      const model = normalizeModel(task.model || getDistillModel());
       const claudeArgs = ['-p', '--model', model, '--dangerously-skip-permissions'];
       for (const t of (task.allowedTools || [])) claudeArgs.push('--allowedTools', t);
 
@@ -209,8 +211,9 @@ function createExecCommandHandler(deps) {
       const proc = activeProcesses.get(chatId);
       if (proc && proc.child) {
         proc.aborted = true;
-        try { process.kill(-proc.child.pid, 'SIGINT'); } catch { proc.child.kill('SIGINT'); }
-        await bot.sendMessage(chatId, '⏹ Stopping Claude...');
+        const signal = proc.killSignal || 'SIGTERM';
+        try { process.kill(-proc.child.pid, signal); } catch { proc.child.kill(signal); }
+        await bot.sendMessage(chatId, '⏹ Stopping current engine task...');
       } else {
         await bot.sendMessage(chatId, 'No active task to stop.');
       }
@@ -228,7 +231,8 @@ function createExecCommandHandler(deps) {
       const proc = activeProcesses.get(chatId);
       if (proc && proc.child) {
         proc.aborted = true;
-        try { process.kill(-proc.child.pid, 'SIGINT'); } catch { proc.child.kill('SIGINT'); }
+        const signal = proc.killSignal || 'SIGTERM';
+        try { process.kill(-proc.child.pid, signal); } catch { proc.child.kill(signal); }
       }
       const session = getSession(chatId);
       const name = session ? getSessionName(session.id) : null;
@@ -244,6 +248,10 @@ function createExecCommandHandler(deps) {
         await bot.sendMessage(chatId, '❌ No active session to compact.');
         return true;
       }
+      if (String(session.engine || '').toLowerCase() === 'codex') {
+        await bot.sendMessage(chatId, '⚠️ Codex 会话暂不支持 /compact，请继续在同一会话里对话。');
+        return true;
+      }
       await bot.sendMessage(chatId, '🗜 Compacting session...');
 
       // Step 1: Read conversation from JSONL (fast, no Claude needed)
@@ -298,9 +306,9 @@ function createExecCommandHandler(deps) {
         digest = entry + digest;
       }
 
-      // Step 3: Summarize with haiku (new process, no --resume, fast)
+      // Step 3: Summarize with distill model (new process, no --resume, fast)
       const daemonCfg = loadConfig().daemon || {};
-      const compactArgs = ['-p', '--model', 'haiku', '--no-session-persistence'];
+      const compactArgs = ['-p', '--model', getDistillModel(), '--no-session-persistence'];
       if (daemonCfg.dangerously_skip_permissions) compactArgs.push('--dangerously-skip-permissions');
       const { output, error } = await spawnClaudeAsync(
         compactArgs,
@@ -316,7 +324,7 @@ function createExecCommandHandler(deps) {
       // Step 4: Create new session with the summary
       const model = daemonCfg.model || 'opus';
       const oldName = getSessionName(session.id);
-      const newSession = createSession(chatId, session.cwd, oldName ? oldName + ' (compacted)' : '');
+      const newSession = createSession(chatId, session.cwd, oldName ? oldName + ' (compacted)' : '', session.engine || 'claude');
       const initArgs = ['-p', '--session-id', newSession.id, '--model', model];
       if (daemonCfg.dangerously_skip_permissions) initArgs.push('--dangerously-skip-permissions');
       const preamble = buildProfilePreamble();

package/scripts/daemon-notify.js

@@ -58,7 +58,43 @@ function createNotifier(deps) {
     }
   }
 
-  return { notify, notifyAdmin };
+  /**
+   * Send only to personal (non-agent-bound) chat IDs.
+   * Agent-bound group chats (those in chat_agent_map) are excluded.
+   * Falls back to fsIds[0] if no personal chats are found.
+   * Used for system notifications that should not spam every agent group.
+   */
+  async function notifyPersonal(message) {
+    const config = getConfig();
+    const { telegramBridge, feishuBridge } = getBridges();
+
+    if (feishuBridge && feishuBridge.bot) {
+      const chatAgentMap = (config.feishu && config.feishu.chat_agent_map) || {};
+      const fsIds = (config.feishu && config.feishu.allowed_chat_ids) || [];
+      // Personal chats = allowed IDs not bound to any agent
+      const personalIds = fsIds.filter(id => !chatAgentMap[id]);
+      const targetIds = personalIds.length > 0 ? personalIds : fsIds.slice(0, 1);
+      for (const chatId of targetIds) {
+        try { await feishuBridge.bot.sendMessage(chatId, message); } catch (e) {
+          log('ERROR', `Feishu personal notify failed ${chatId}: ${e.message}`);
+        }
+      }
+    }
+
+    if (telegramBridge && telegramBridge.bot) {
+      const tgAgentMap = (config.telegram && config.telegram.chat_agent_map) || {};
+      const tgIds = (config.telegram && config.telegram.allowed_chat_ids) || [];
+      const personalIds = tgIds.filter(id => !tgAgentMap[id]);
+      const targetIds = personalIds.length > 0 ? personalIds : tgIds.slice(0, 1);
+      for (const chatId of targetIds) {
+        try { await telegramBridge.bot.sendMarkdown(chatId, message); } catch (e) {
+          log('ERROR', `Telegram personal notify failed ${chatId}: ${e.message}`);
+        }
+      }
+    }
+  }
+
+  return { notify, notifyAdmin, notifyPersonal };
 }
 
 module.exports = { createNotifier };