metame-cli 1.4.34 → 1.5.1

package/scripts/daemon-admin-commands.js

@@ -5,6 +5,10 @@ const {
   CORE_USAGE_CATEGORIES,
   USAGE_CATEGORY_LABEL,
 } = require('./usage-classifier');
+const { IS_WIN } = require('./platform');
+const { ENGINE_MODEL_CONFIG } = require('./daemon-engine-runtime');
+let mentorEngine = null;
+try { mentorEngine = require('./mentor-engine'); } catch { /* optional */ }
 
 function createAdminCommandHandler(deps) {
   const {
@@ -30,6 +34,9 @@ function createAdminCommandHandler(deps) {
     getMessageQueue,
     loadState,
     saveState,
+    getDefaultEngine = () => 'claude',
+    setDefaultEngine = () => {},
+    getDistillModel = () => 'haiku',
   } = deps;
 
   function resolveProjectKey(targetName, projects) {
@@ -92,6 +99,61 @@ function createAdminCommandHandler(deps) {
     return 'unspecified';
   }
 
+  function modeFromLevel(level) {
+    const n = Number(level);
+    if (!Number.isFinite(n)) return 'gentle';
+    if (n >= 8) return 'intense';
+    if (n >= 4) return 'active';
+    return 'gentle';
+  }
+
+  function parseDistillModelIntent(input) {
+    const text = String(input || '').trim();
+    if (!text || text.startsWith('/')) return null;
+    if (!/(蒸馏|distill|提炼|提纯)/i.test(text)) return null;
+    const setVerb = '(?:改成|改为|设为|设置|切到|切换到|换成|改用|使用|用|set|switch|use)';
+    if (!(new RegExp(setVerb, 'i')).test(text)) return null;
+
+    const explicitModel = text.match(new RegExp(`(?:蒸馏模型|模型|distill\\s*model|model)\\s*(?:${setVerb}|to|is)?\\s*[:：]?\\s*([a-zA-Z0-9._-]{2,80})`, 'i'));
+    if (explicitModel) return { model: explicitModel[1] };
+
+    if (/(蒸馏模型|模型|distill\s*model|model)/i.test(text)) {
+      const quotedModel = text.match(/[“"'「]([a-zA-Z0-9._-]{2,80})[”"'」]/);
+      if (quotedModel) return { model: quotedModel[1] };
+    }
+
+    const knownToken = text.match(new RegExp(`${setVerb}\\s*(?:为|成|到|to)?\\s*[:：]?\\s*(gpt-5\\.1-codex-mini|gpt-5-mini|haiku|sonnet|opus|5\\.1mini|5mini|codex-mini)\\b`, 'i'));
+    if (knownToken) return { model: knownToken[1] };
+
+    return null;
+  }
+
+  function ensureMentorConfig(cfg) {
+    if (!cfg.daemon) cfg.daemon = {};
+    if (!cfg.daemon.mentor || typeof cfg.daemon.mentor !== 'object') {
+      cfg.daemon.mentor = {};
+    }
+    const mentor = cfg.daemon.mentor;
+    if (typeof mentor.enabled !== 'boolean') mentor.enabled = false;
+    if (!Number.isFinite(Number(mentor.friction_level))) mentor.friction_level = 3;
+    if (!mentor.mode || !['gentle', 'active', 'intense'].includes(String(mentor.mode))) {
+      mentor.mode = modeFromLevel(mentor.friction_level);
+    }
+    if (!Array.isArray(mentor.exclude_agents)) mentor.exclude_agents = ['personal', 'xianyu'];
+    if (!Array.isArray(mentor.emotion_keywords_extra)) mentor.emotion_keywords_extra = [];
+    return mentor;
+  }
+
+  function hasCli(execSyncFn, bin) {
+    try {
+      const cmd = process.platform === 'win32' ? `where ${bin}` : `which ${bin}`;
+      execSyncFn(cmd, { encoding: 'utf8', ...(process.platform === 'win32' ? { windowsHide: true } : {}) });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
   async function handleAdminCommand(ctx) {
     const { bot, chatId, text } = ctx;
     const state = ctx.state || {};
@@ -195,17 +257,69 @@ function createAdminCommandHandler(deps) {
         return { handled: true, config };
       }
 
+      // /skill-evo approve <id> — approve a workflow_proposal and dispatch skill creation
+      const approveMatch = arg.match(/^approve\s+(\S+)$/i);
+      if (approveMatch) {
+        const id = approveMatch[1];
+        // Find the queue item (search both pending and notified states)
+        const item = skillEvolution.listQueueItems({ status: ['pending', 'notified'], limit: 200 })
+          .find(i => i.id === id && i.type === 'workflow_proposal');
+        if (!item) {
+          await bot.sendMessage(chatId, `❌ 未找到 workflow_proposal: ${id}`);
+          return { handled: true, config };
+        }
+        // Build skill-creator prefilled prompt
+        const toolsSig = (item.tools_signature || []).join(', ');
+        const prefilledPrompt = [
+          '/skill-creator',
+          `创建一个新技能，自动化以下工作流：`,
+          `工作流模式: ${item.search_hint || item.reason}`,
+          toolsSig ? `常用工具: ${toolsSig}` : '',
+          item.example_prompt ? `用户示例: "${item.example_prompt}"` : '',
+          `该技能应封装这个多步工作流为单一可调用技能。`,
+        ].filter(Boolean).join('\n');
+        // Dispatch to metame agent for skill creation (async — must not block event loop)
+        try {
+          const HOME = require('os').homedir();
+          const dispatchBin = require('path').join(HOME, '.metame', 'bin', 'dispatch_to');
+          const { execFile } = require('child_process');
+          const { promisify } = require('util');
+          const execFileAsync = promisify(execFile);
+          // dispatch_to is a Node.js script; on Windows shebang resolution is unavailable,
+          // so invoke via node explicitly for cross-platform safety
+          const cmd = IS_WIN ? process.execPath : dispatchBin;
+          const cmdArgs = IS_WIN ? [dispatchBin, 'metame', prefilledPrompt] : ['metame', prefilledPrompt];
+          await execFileAsync(cmd, cmdArgs, { encoding: 'utf8', timeout: 15000 });
+          // Mark installed only after successful dispatch
+          skillEvolution.resolveQueueItemById(id, 'installed');
+          await bot.sendMessage(chatId, `✅ 已派发给 Jarvis 创建技能，完成后会通知你\n工作流: ${item.search_hint || item.reason}`);
+        } catch (e) {
+          // Dispatch failed — don't mark installed, keep in queue
+          await bot.sendMessage(chatId, `⚠️ 自动派发失败: ${e.message}\n提案仍在队列中，可重试: /skill-evo approve ${id}`);
+        }
+        return { handled: true, config };
+      }
+
       const dismissMatch = arg.match(/^(?:dismiss|skip|ignored?)\s+(\S+)$/i);
       if (dismissMatch) {
         const id = dismissMatch[1];
+        // Check if this is a workflow_proposal — if so, reset the sketch
+        const item = skillEvolution.listQueueItems({ status: ['pending', 'notified'], limit: 200 })
+          .find(i => i.id === id);
         const ok = skillEvolution.resolveQueueItemById
           ? skillEvolution.resolveQueueItemById(id, 'dismissed')
           : false;
+        // Reset workflow sketch so it can re-accumulate
+        if (ok && item && item.type === 'workflow_proposal' && item.workflow_sketch_id) {
+          if (skillEvolution.resetWorkflowSketch) {
+            skillEvolution.resetWorkflowSketch(item.workflow_sketch_id);
+          }
+        }
         await bot.sendMessage(chatId, ok ? `✅ 已标记 dismissed: ${id}` : `❌ 未找到可处理项: ${id}`);
         return { handled: true, config };
       }
 
-      await bot.sendMessage(chatId, '用法: /skill-evo list | /skill-evo done <id> | /skill-evo dismiss <id>');
+      await bot.sendMessage(chatId, '用法: /skill-evo list | /skill-evo done <id> | /skill-evo dismiss <id> | /skill-evo approve <id>');
       return { handled: true, config };
     }
 
@@ -635,6 +749,68 @@ function createAdminCommandHandler(deps) {
       return { handled: true, config };
     }
 
+    if (text === '/mentor' || text.startsWith('/mentor ')) {
+      try {
+        backupConfig();
+        const cfg = yaml.load(fs.readFileSync(CONFIG_FILE, 'utf8')) || {};
+        const mentorCfg = ensureMentorConfig(cfg);
+        const arg = text.slice('/mentor'.length).trim();
+
+        if (!arg || arg === 'status') {
+          const status = mentorEngine && typeof mentorEngine.getRuntimeStatus === 'function'
+            ? mentorEngine.getRuntimeStatus()
+            : { debt_count: 0, cooldown_remaining_ms: 0 };
+          const mode = String(mentorCfg.mode || modeFromLevel(mentorCfg.friction_level));
+          const level = Number(mentorCfg.friction_level || 0);
+          const cooldownSec = Math.ceil((Number(status.cooldown_remaining_ms) || 0) / 1000);
+          const lines = [
+            `Mentor: ${mentorCfg.enabled ? 'ON' : 'OFF'}`,
+            `Mode: ${mode}`,
+            `Friction level: ${level}`,
+            `Debts: ${status.debt_count || 0}`,
+            `Emotion cooldown: ${cooldownSec > 0 ? `${cooldownSec}s` : '0s'}`,
+            'Zone: n/a (runtime)',
+          ];
+          await bot.sendMessage(chatId, lines.join('\n'));
+          return { handled: true, config };
+        }
+
+        if (arg === 'on' || arg === 'off') {
+          mentorCfg.enabled = arg === 'on';
+          writeConfigSafe(cfg);
+          config = loadConfig();
+          await bot.sendMessage(chatId, mentorCfg.enabled
+            ? '✅ Mentor mode enabled.'
+            : '✅ Mentor mode disabled.');
+          return { handled: true, config };
+        }
+
+        const mLevel = arg.match(/^level\s+(-?\d{1,2})$/i);
+        if (mLevel) {
+          let level = Number(mLevel[1]);
+          if (!Number.isFinite(level)) level = 3;
+          level = Math.max(0, Math.min(10, Math.floor(level)));
+          mentorCfg.friction_level = level;
+          mentorCfg.mode = modeFromLevel(level);
+          writeConfigSafe(cfg);
+          config = loadConfig();
+          await bot.sendMessage(chatId, `✅ Mentor level set to ${level} (${mentorCfg.mode}).`);
+          return { handled: true, config };
+        }
+
+        await bot.sendMessage(chatId, [
+          '用法:',
+          '/mentor on',
+          '/mentor off',
+          '/mentor level <0-10>',
+          '/mentor status',
+        ].join('\n'));
+      } catch (e) {
+        await bot.sendMessage(chatId, `❌ Mentor command failed: ${e.message}`);
+      }
+      return { handled: true, config };
+    }
+
     if (text === '/reload') {
       if (global._metameReload) {
         const r = global._metameReload();
@@ -727,6 +903,10 @@ function createAdminCommandHandler(deps) {
       const validModels = ['sonnet', 'opus', 'haiku'];
       const checks = [];
       let issues = 0;
+      const activeProvider = providerMod && typeof providerMod.getActiveName === 'function'
+        ? providerMod.getActiveName()
+        : 'anthropic';
+      const isCustomProvider = activeProvider !== 'anthropic';
 
       let cfg = null;
       try {
@@ -738,20 +918,33 @@ function createAdminCommandHandler(deps) {
       }
 
       const m = (cfg && cfg.daemon && cfg.daemon.model) || 'opus';
-      if (validModels.includes(m)) {
+      const modelOk = isCustomProvider
+        ? /^[a-zA-Z0-9._-]{2,80}$/.test(String(m || '').trim())
+        : validModels.includes(m);
+      if (modelOk) {
         checks.push(`✅ 模型: ${m}`);
       } else {
-        checks.push(`❌ 模型: ${m} (无效)`);
+        checks.push(`❌ 模型: ${m} (${isCustomProvider ? '格式无效' : '无效'})`);
         issues++;
       }
 
-      try {
-        execSync(process.platform === 'win32' ? 'where claude' : 'which claude', { encoding: 'utf8' });
-        checks.push('✅ Claude CLI');
-      } catch {
-        checks.push('❌ Claude CLI 未找到');
+      const hasClaude = hasCli(execSync, 'claude');
+      const hasCodex = hasCli(execSync, 'codex');
+      checks.push(hasClaude ? '✅ Claude CLI' : '⚠️ Claude CLI 未找到');
+      checks.push(hasCodex ? '✅ Codex CLI' : '⚠️ Codex CLI 未找到');
+
+      const currentEngine = getDefaultEngine() === 'codex' ? 'codex' : 'claude';
+      if (currentEngine === 'claude' && !hasClaude) {
+        checks.push('❌ 当前默认引擎是 claude，但 Claude CLI 不可用');
         issues++;
       }
+      if (currentEngine === 'codex' && !hasCodex) {
+        checks.push('❌ 当前默认引擎是 codex，但 Codex CLI 不可用');
+        issues++;
+      }
+
+      checks.push(`✅ 默认引擎: ${currentEngine}`);
+      checks.push(`✅ Provider: ${activeProvider}${isCustomProvider ? ' (custom)' : ''}`);
 
       const bakFile = CONFIG_FILE + '.bak';
       const hasBak = fs.existsSync(bakFile);
@@ -795,38 +988,54 @@ function createAdminCommandHandler(deps) {
       return { handled: true, config };
     }
 
-    // /model [name] — switch model (interactive, accepts any name for custom providers)
+    // /model [name] — switch session model, engine-aware
     if (text === '/model' || text.startsWith('/model ')) {
       const arg = text.slice(6).trim();
-      const builtinModels = ['sonnet', 'opus', 'haiku'];
-      const currentModel = (config.daemon && config.daemon.model) || 'opus';
-      const activeProvider = providerMod ? providerMod.getActiveName() : 'anthropic';
-      const isCustomProvider = activeProvider !== 'anthropic';
+      const currentEngine = getDefaultEngine();
+      const engineCfg = ENGINE_MODEL_CONFIG[currentEngine] || ENGINE_MODEL_CONFIG.claude;
+      // options is [{value, label}, ...] — normalize to a flat list for logic
+      const optionEntries = (engineCfg.options || []).map(o =>
+        typeof o === 'string' ? { value: o, label: o } : o
+      );
+      const optionValues = optionEntries.map(o => o.value);
+      const daemonCfg = config.daemon || {};
+      const currentModel = (daemonCfg.models && daemonCfg.models[currentEngine])
+        || daemonCfg.model   // legacy fallback
+        || engineCfg.main;
+      // providerMod manages Claude providers only — for codex use engineCfg.provider
+      const activeProvider = (currentEngine === 'claude' && providerMod)
+        ? providerMod.getActiveName()
+        : engineCfg.provider;
+      const isBuiltinProvider = activeProvider === engineCfg.provider;
+      const distillModel = getDistillModel();
+      const hintLine = engineCfg.hint ? `\n💡 ${engineCfg.hint}` : (!isBuiltinProvider ? `\n💡 ${activeProvider} 可输入任意模型名` : '');
 
       if (!arg) {
-        const hint = isCustomProvider ? `\n💡 ${activeProvider} 可输入任意模型名` : '';
-        if (bot.sendButtons) {
-          const buttons = builtinModels.map(m => [{
-            text: m === currentModel ? `${m} ✓` : m,
-            callback_data: `/model ${m}`,
+        const statusLine = `🤖 [${currentEngine}] 会话模型: ${currentModel}  Provider: ${activeProvider}\n🧪 后台轻量: ${distillModel}  (/distill-model 修改)${hintLine}`;
+        if (bot.sendButtons && optionEntries.length > 0) {
+          const buttons = optionEntries.map(({ value, label }) => [{
+            text: value === currentModel ? `${label} ✓` : label,
+            callback_data: `/model ${value}`,
           }]);
-          await bot.sendButtons(chatId, `🤖 当前模型: ${currentModel}${hint}`, buttons);
+          await bot.sendButtons(chatId, statusLine, buttons);
         } else {
-          await bot.sendMessage(chatId, `🤖 当前模型: ${currentModel}\n可选: ${builtinModels.join(', ')}${hint}`);
+          const optionHint = optionValues.length > 0 ? `\n\n可选: ${optionValues.join(', ')}` : '';
+          await bot.sendMessage(chatId, `${statusLine}${optionHint}`);
         }
         return { handled: true, config };
       }
 
       const normalizedArg = arg.toLowerCase();
-      // Builtin providers only accept builtin model names
-      if (!isCustomProvider && !builtinModels.includes(normalizedArg)) {
-        await bot.sendMessage(chatId, `❌ 无效模型: ${arg}\n可选: ${builtinModels.join(', ')}\n💡 切换到自定义 provider 后可用任意模型名`);
+      // Only restrict model names for claude with anthropic provider (known fixed set)
+      // codex always allows free-form input (OpenAI models change frequently)
+      if (currentEngine === 'claude' && isBuiltinProvider && !optionValues.includes(normalizedArg)) {
+        await bot.sendMessage(chatId, `❌ 无效模型: ${arg}\n可选: ${optionValues.join(', ')}\n💡 切换到自定义 provider 后可用任意模型名`);
         return { handled: true, config };
       }
 
-      const modelName = builtinModels.includes(normalizedArg) ? normalizedArg : arg;
+      const modelName = optionValues.includes(normalizedArg) ? normalizedArg : arg;
       if (modelName === currentModel) {
-        await bot.sendMessage(chatId, `🤖 已经是 ${modelName}`);
+        await bot.sendMessage(chatId, `🤖 已经是 ${modelName}（后台轻量模型: ${distillModel}）`);
         return { handled: true, config };
       }
 
@@ -834,10 +1043,11 @@ function createAdminCommandHandler(deps) {
         backupConfig();
         const cfg = yaml.load(fs.readFileSync(CONFIG_FILE, 'utf8')) || {};
         if (!cfg.daemon) cfg.daemon = {};
-        cfg.daemon.model = modelName;
+        if (!cfg.daemon.models) cfg.daemon.models = {};
+        cfg.daemon.models[currentEngine] = modelName;
         writeConfigSafe(cfg);
         config = loadConfig();
-        await bot.sendMessage(chatId, `✅ 模型已切换: ${currentModel} → ${modelName}`);
+        await bot.sendMessage(chatId, `✅ [${currentEngine}] 会话模型: ${currentModel} → ${modelName}\n🧪 后台轻量模型: ${distillModel}（如需修改用 /distill-model）`);
       } catch (e) {
         await bot.sendMessage(chatId, `❌ 切换失败: ${e.message}`);
       }
@@ -867,10 +1077,100 @@ function createAdminCommandHandler(deps) {
       return { handled: true, config };
     }
 
+    // /engine [name] — show or switch default engine (claude/codex)
+    // Switching engine auto-syncs: distill model + preferred provider (if available)
+    if (text === '/engine' || text.startsWith('/engine ')) {
+      const arg = text.slice('/engine'.length).trim().toLowerCase();
+      if (!arg) {
+        const cur = getDefaultEngine();
+        const curEngineCfg = ENGINE_MODEL_CONFIG[cur] || ENGINE_MODEL_CONFIG.claude;
+        const activeProvider = (cur === 'claude' && providerMod)
+          ? providerMod.getActiveName()
+          : curEngineCfg.provider;
+        const distill = getDistillModel();
+        const daemonCfg = config.daemon || {};
+        const currentModel = (daemonCfg.models && daemonCfg.models[cur])
+          || daemonCfg.model || curEngineCfg.main;
+        await bot.sendMessage(chatId, [
+          `🔧 引擎: ${cur}  |  Provider: ${activeProvider}`,
+          `🤖 会话模型: ${currentModel}  |  后台轻量: ${distill}`,
+          '',
+          '用法: /engine claude 或 /engine codex',
+          '切换引擎将自动同步 distill model 和首选 provider',
+        ].join('\n'));
+        return { handled: true, config };
+      }
+      if (arg !== 'claude' && arg !== 'codex') {
+        await bot.sendMessage(chatId, `❌ 不支持的引擎: ${arg}\n可选: claude, codex`);
+        return { handled: true, config };
+      }
+
+      const preferredProvider = (ENGINE_MODEL_CONFIG[arg] || {}).provider;
+
+      setDefaultEngine(arg); // syncs distill model + providerMod.setEngine (no longer resets session model)
+      const distill = getDistillModel();
+      const freshCfg = loadConfig();
+      const freshDaemon = freshCfg.daemon || {};
+      const targetEngineCfg = ENGINE_MODEL_CONFIG[arg] || ENGINE_MODEL_CONFIG.claude;
+      const syncedModel = (freshDaemon.models && freshDaemon.models[arg])
+        || freshDaemon.model || targetEngineCfg.main;
+
+      // Auto-switch provider if the preferred one exists in providers.yaml
+      let providerNote = '';
+      if (providerMod && preferredProvider) {
+        try {
+          providerMod.setActive(preferredProvider);
+          providerNote = `\n🔌 Provider 已同步: ${preferredProvider}`;
+        } catch {
+          // Provider not configured — just inform
+          const cur = providerMod ? providerMod.getActiveName() : '';
+          providerNote = `\n🔌 Provider: ${cur}（如需切换请 /provider ${preferredProvider}）`;
+        }
+      }
+
+      await bot.sendMessage(chatId, `✅ 引擎已切换: ${arg}\n🤖 会话模型: ${syncedModel}\n🧪 后台轻量模型: ${distill}${providerNote}`);
+      return { handled: true, config };
+    }
+
+    // /distill-model [name] — show or update distill model
+    if (text === '/distill-model' || text.startsWith('/distill-model ')) {
+      if (!providerMod || typeof providerMod.getDistillModel !== 'function' || typeof providerMod.setDistillModel !== 'function') {
+        await bot.sendMessage(chatId, '❌ Distill model config is not available.');
+        return { handled: true, config };
+      }
+      const arg = text.slice('/distill-model'.length).trim();
+      if (!arg) {
+        await bot.sendMessage(chatId, `🧪 当前蒸馏模型: ${providerMod.getDistillModel()}\n用法: /distill-model <model>\n示例: /distill-model gpt-5.1-codex-mini`);
+        return { handled: true, config };
+      }
+      try {
+        providerMod.setDistillModel(arg);
+        await bot.sendMessage(chatId, `✅ 蒸馏模型已更新为: ${providerMod.getDistillModel()}`);
+      } catch (e) {
+        await bot.sendMessage(chatId, `❌ 设置失败: ${e.message}`);
+      }
+      return { handled: true, config };
+    }
+
+    const nlDistillIntent = parseDistillModelIntent(text);
+    if (nlDistillIntent) {
+      if (!providerMod || typeof providerMod.setDistillModel !== 'function' || typeof providerMod.getDistillModel !== 'function') {
+        await bot.sendMessage(chatId, '❌ Distill model config is not available.');
+        return { handled: true, config };
+      }
+      try {
+        providerMod.setDistillModel(nlDistillIntent.model);
+        await bot.sendMessage(chatId, `✅ 已按自然语言请求更新蒸馏模型: ${providerMod.getDistillModel()}`);
+      } catch (e) {
+        await bot.sendMessage(chatId, `❌ 设置失败: ${e.message}`);
+      }
+      return { handled: true, config };
+    }
+
     return { handled: false, config };
   }
 
-  return { handleAdminCommand };
+  return { handleAdminCommand, _private: { parseDistillModelIntent } };
 }
 
 module.exports = { createAdminCommandHandler };

package/scripts/daemon-agent-commands.js

@@ -28,8 +28,26 @@ function createAgentCommandHandler(deps) {
     attachOrCreateSession,
     agentFlowTtlMs,
     agentBindTtlMs,
+    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 targetCwd = normalizeCwd(cwd);
+    for (const proj of Object.values(cfg.projects || {})) {
+      if (!proj || !proj.cwd) continue;
+      if (normalizeCwd(proj.cwd) === targetCwd) {
+        return normalizeEngineName(proj.engine);
+      }
+    }
+    return null;
+  }
+
   // Pending activations have no TTL — they persist until consumed.
   // The creating chatId is stored to prevent self-activation.
 
@@ -127,7 +145,12 @@ function createAgentCommandHandler(deps) {
       const action = res.data.isNewProject ? '绑定成功' : '重新绑定';
       const displayCwd = String(res.data.cwd || '').replace(HOME, '~');
       if (res.data.cwd && typeof attachOrCreateSession === 'function') {
-        attachOrCreateSession(chatId, normalizeCwd(res.data.cwd), p.name || agentName || res.data.projectKey || '');
+        attachOrCreateSession(
+          chatId,
+          normalizeCwd(res.data.cwd),
+          p.name || agentName || res.data.projectKey || '',
+          p.engine || getDefaultEngine()
+        );
       }
       await bot.sendMessage(chatId, `${icon} ${p.name || agentName} ${action}\n目录: ${displayCwd}`);
       return { ok: true, data: res.data };
@@ -140,7 +163,7 @@ function createAgentCommandHandler(deps) {
     }
     const fallbackCwd = (fallback.data && fallback.data.cwd) || agentCwd;
     if (fallbackCwd && typeof attachOrCreateSession === 'function') {
-      attachOrCreateSession(chatId, normalizeCwd(fallbackCwd), agentName || '');
+      attachOrCreateSession(chatId, normalizeCwd(fallbackCwd), agentName || '', getDefaultEngine());
     }
     return {
       ok: true,
@@ -163,9 +186,9 @@ function createAgentCommandHandler(deps) {
 
   async function createAgentViaUnifiedApi(chatId, name, dir, roleDesc, opts = {}) {
     // Default: skip binding the creating chat — let the target group activate via /activate
-    const { skipChatBinding = true } = opts;
+    const { skipChatBinding = true, engine = null } = opts;
     if (agentTools && typeof agentTools.createNewWorkspaceAgent === 'function') {
-      const res = await agentTools.createNewWorkspaceAgent(name, dir, roleDesc, chatId, { skipChatBinding });
+      const res = await agentTools.createNewWorkspaceAgent(name, dir, roleDesc, chatId, { skipChatBinding, engine });
       if (res.ok && skipChatBinding && res.data && res.data.projectKey) {
         storePendingActivation(res.data.projectKey, name, res.data.cwd, chatId);
       }
@@ -273,10 +296,14 @@ function createAgentCommandHandler(deps) {
       const cwd = fullMatch.projectPath || (getSession(chatId) && getSession(chatId).cwd) || HOME;
 
       const state2 = loadState();
+      const cfgForEngine = loadConfig();
+      const engineByTargetCwd = inferEngineByCwd(cfgForEngine, cwd);
+      const currentEngine = normalizeEngineName(state2.sessions[chatId] && state2.sessions[chatId].engine);
       state2.sessions[chatId] = {
         id: sessionId,
         cwd,
         started: true,
+        engine: engineByTargetCwd || currentEngine,
       };
       saveState(state2);
       const name = fullMatch.customTitle;
@@ -380,6 +407,10 @@ function createAgentCommandHandler(deps) {
           return true;
         }
         const cwd = normalizeCwd(boundProj.cwd);
+        // Lazy migration: ensure soul layer exists for agents created before this feature
+        if (agentTools && typeof agentTools.repairAgentSoul === 'function') {
+          await agentTools.repairAgentSoul(cwd).catch(() => {});
+        }
         const inlineDelta = agentParts.slice(1).join(' ').trim();
         if (inlineDelta) {
           await bot.sendMessage(chatId, '⏳ 正在更新 CLAUDE.md...');
@@ -443,6 +474,83 @@ function createAgentCommandHandler(deps) {
         return true;
       }
 
+
+      // /agent soul [repair | edit <text>]
+      // Manage the agent's soul.md identity file.
+      // "repair"  → lazy-migration: create ~/.metame/agents/<id>/ and project symlinks.
+      // "edit"    → overwrite soul.md with provided text.
+      // (default) → display current SOUL.md content.
+      if (agentSub === 'soul') {
+        const soulAction = agentParts[1] || '';
+        const cfg = loadConfig();
+        const { boundProj } = getBoundProject(chatId, cfg);
+        if (!boundProj || !boundProj.cwd) {
+          await bot.sendMessage(chatId, '❌ 当前群未绑定 Agent，请先 /agent bind <名称> <目录>');
+          return true;
+        }
+        const cwd = normalizeCwd(boundProj.cwd);
+        const soulPath = path.join(cwd, 'SOUL.md');
+
+        if (soulAction === 'repair') {
+          if (agentTools && typeof agentTools.repairAgentSoul === 'function') {
+            const res = await agentTools.repairAgentSoul(cwd);
+            if (!res.ok) {
+              await bot.sendMessage(chatId, '❌ Soul 修复失败: ' + res.error);
+            } else {
+              const viewModes = res.data.views
+                ? Object.entries(res.data.views).map(([k, v]) => k + ':' + v).join(', ')
+                : '—';
+              await bot.sendMessage(chatId, [
+                '✅ Agent Soul 层已就绪',
+                'agent_id: ' + res.data.agentId,
+                '链接方式: ' + viewModes,
+                '',
+                '文件位置:',
+                '  SOUL.md   → ~/.metame/agents/' + res.data.agentId + '/soul.md',
+                '  MEMORY.md → ~/.metame/agents/' + res.data.agentId + '/memory-snapshot.md',
+              ].join('\n'));
+            }
+          } else {
+            await bot.sendMessage(chatId, '❌ agentTools 不可用');
+          }
+          return true;
+        }
+
+        if (soulAction === 'edit') {
+          const soulText = agentParts.slice(2).join(' ').trim();
+          if (!soulText) {
+            await bot.sendMessage(chatId, '用法: /agent soul edit <新内容>\n当前内容: /agent soul');
+            return true;
+          }
+          try {
+            fs.writeFileSync(soulPath, soulText, 'utf8');
+            await bot.sendMessage(chatId, '✅ SOUL.md 已更新');
+          } catch (e) {
+            await bot.sendMessage(chatId, '❌ 写入失败: ' + e.message);
+          }
+          return true;
+        }
+
+        // Default: show current SOUL.md content
+        if (!fs.existsSync(soulPath)) {
+          await bot.sendMessage(chatId, [
+            '⚠️ SOUL.md 不存在',
+            '',
+            '老项目或刚绑定的 Agent 可能尚未建立 Soul 层。',
+            '运行 /agent soul repair 自动生成。',
+          ].join('\n'));
+          return true;
+        }
+        try {
+          const soulContent = fs.readFileSync(soulPath, 'utf8').trim().slice(0, 2000);
+          await bot.sendMessage(chatId, '📋 当前 Soul:\n\n' + soulContent);
+        } catch (e) {
+          await bot.sendMessage(chatId, '❌ 读取 SOUL.md 失败: ' + e.message);
+        }
+        return true;
+      }
+
+
       // /agent (no sub command): show agent switch picker
       {
         const projects = config.projects || {};
@@ -485,7 +593,36 @@ function createAgentCommandHandler(deps) {
             }
           }
         }
-        // No pending activation at all — guide to manual bind
+        // No pending activation — fall back to scanning daemon.yaml for unbound projects
+        const allBoundKeys = new Set(Object.values({
+          ...(cfg.telegram ? cfg.telegram.chat_agent_map : {}),
+          ...(cfg.feishu ? cfg.feishu.chat_agent_map : {}),
+        }));
+        const unboundProjects = Object.entries(cfg.projects || {})
+          .filter(([key, p]) => p && p.cwd && !allBoundKeys.has(key))
+          .map(([key, p]) => ({ key, name: p.name || key, cwd: p.cwd, icon: p.icon || '🤖' }));
+
+        if (unboundProjects.length === 1) {
+          // Exactly one unbound project — auto-bind using project KEY (not display name)
+          // to ensure toProjectKey() resolves to the correct existing key in daemon.yaml
+          const proj = unboundProjects[0];
+          const bindRes2 = await bindViaUnifiedApi(bot, chatId, proj.key, proj.cwd);
+          if (bindRes2.ok) pendingActivations && pendingActivations.delete(proj.key);
+          return true;
+        }
+
+        if (unboundProjects.length > 1) {
+          // Multiple unbound projects — show pick list using project keys
+          const lines = ['请选择要激活的 Agent：', ''];
+          for (const p of unboundProjects) {
+            lines.push(`${p.icon} ${p.name}  →  \`/agent bind ${p.key} ${p.cwd}\``);
+          }
+          lines.push('\n发送对应命令即可绑定此群。');
+          await bot.sendMessage(chatId, lines.join('\n'));
+          return true;
+        }
+
+        // Truly nothing to activate
         await bot.sendMessage(chatId,
           '没有待激活的 Agent。\n\n如果已创建过 Agent，直接用:\n`/agent bind <名称> <目录>`\n即可绑定，不需要重新创建。'
         );
@@ -517,4 +654,6 @@ function createAgentCommandHandler(deps) {
   return { handleAgentCommand };
 }
 
-module.exports = { createAgentCommandHandler };
+module.exports = {
+  createAgentCommandHandler,
+};