metame-cli 1.5.16 → 1.5.17

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.5.16",
+    "version": "1.5.17",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {

package/scripts/daemon-admin-commands.js

@@ -6,7 +6,7 @@ const {
   USAGE_CATEGORY_LABEL,
 } = require('./usage-classifier');
 const { IS_WIN } = require('./platform');
-const { ENGINE_MODEL_CONFIG, resolveEngineModel } = require('./daemon-engine-runtime');
+const { ENGINE_MODEL_CONFIG, resolveEngineModel, normalizeClaudeModel } = require('./daemon-engine-runtime');
 const { resolveProjectKey: _resolveProjectKey } = require('./daemon-team-dispatch');
 const {
   parseRemoteTargetRef,
@@ -1439,7 +1439,7 @@ function createAdminCommandHandler(deps) {
       return { handled: true, config };
     }
 
-    // /doctor — diagnostics; /fix — restore backup; /reset — reset model to sonnet
+    // /doctor — diagnostics; /fix — restore backup; /reset — reset Claude slot to opus
     if (text === '/fix') {
       if (restoreConfig()) {
         await bot.sendMessage(chatId, '✅ 已从备份恢复配置');
@@ -1453,7 +1453,8 @@ function createAdminCommandHandler(deps) {
         backupConfig();
         const cfg = yaml.load(fs.readFileSync(CONFIG_FILE, 'utf8')) || {};
         if (!cfg.daemon) cfg.daemon = {};
-        cfg.daemon.model = 'opus';
+        if (!cfg.daemon.models) cfg.daemon.models = {};
+        cfg.daemon.models.claude = 'opus';
         writeConfigSafe(cfg);
         config = loadConfig();
         await bot.sendMessage(chatId, '✅ 模型已重置为 opus');
@@ -1480,9 +1481,10 @@ function createAdminCommandHandler(deps) {
         issues++;
       }
 
-      const m = (cfg && cfg.daemon && cfg.daemon.model) || 'opus';
+      const daemonCfg = (cfg && cfg.daemon) || {};
+      const m = resolveEngineModel('claude', daemonCfg);
       const modelOk = isCustomProvider
-        ? /^[a-zA-Z0-9._-]{2,80}$/.test(String(m || '').trim())
+        ? ['sonnet', 'opus', 'haiku'].includes(m)
         : validModels.includes(m);
       if (modelOk) {
         checks.push(`✅ 模型: ${m}`);
@@ -1569,7 +1571,11 @@ function createAdminCommandHandler(deps) {
         : engineCfg.provider;
       const isBuiltinProvider = activeProvider === engineCfg.provider;
       const distillModel = getDistillModel();
-      const hintLine = engineCfg.hint ? `\n💡 ${engineCfg.hint}` : (!isBuiltinProvider ? `\n💡 ${activeProvider} 可输入任意模型名` : '');
+      const hintLine = engineCfg.hint
+        ? `\n💡 ${engineCfg.hint}`
+        : (!isBuiltinProvider && currentEngine === 'claude'
+            ? `\n💡 ${activeProvider} 的后端真实模型请在 CC Switch / provider 层配置`
+            : '');
 
       if (!arg) {
         const statusLine = `🤖 [${currentEngine}] 会话模型: ${currentModel}  Provider: ${activeProvider}\n🧪 后台轻量: ${distillModel}  (/distill-model 修改)${hintLine}`;
@@ -1587,10 +1593,13 @@ function createAdminCommandHandler(deps) {
       }
 
       const normalizedArg = arg.toLowerCase();
-      // 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 后可用任意模型名`);
+      // Claude session/config layer only accepts canonical slots; provider mapping stays in CC Switch.
+      if (currentEngine === 'claude' && !optionValues.includes(normalizedArg)) {
+        const suggested = normalizeClaudeModel(arg, '');
+        const hint = suggested
+          ? `\n💡 检测到它更像 Claude 槽位 ${suggested}，请直接用 /model ${suggested}`
+          : '';
+        await bot.sendMessage(chatId, `❌ Claude 会话模型只接受: ${optionValues.join(', ')}\n后端真实模型请在 CC Switch / provider 层配置，不要写进会话模型${hint}`);
         return { handled: true, config };
       }
 

package/scripts/daemon-claude-engine.js

@@ -434,13 +434,10 @@ function createClaudeEngine(deps) {
         const entry = JSON.parse(line);
         const sessionModel = entry && entry.message && entry.message.model;
         if (!sessionModel || sessionModel === '<synthetic>') continue;
-        if (!sessionModel.startsWith('claude-')) {
-          return {
-            shouldResume: false,
-            modelPin: null,
-            reason: 'non-claude-session',
-          };
-        }
+        // Custom Claude-compatible providers may record backend-native model ids
+        // (for example MiniMax) in the JSONL. Those sessions are still resumable;
+        // we only skip model pinning when the family cannot be mapped back to
+        // Claude's alias set.
         // If the configured model is a short alias (sonnet/opus/haiku) and the JSONL model
         // belongs to the same family, do NOT pin — let the alias resolve to the latest version.
         // Only pin when the families genuinely differ (e.g. session was opus, config says sonnet).
@@ -1235,14 +1232,18 @@ function createClaudeEngine(deps) {
    * Reset active provider back to anthropic/opus and reload config.
    * Returns the freshly loaded config so callers can reassign their local variable.
    */
-  function fallbackToDefaultProvider(reason) {
+  function fallbackToDefaultProvider(reason, boundProjectKey = '') {
     log('WARN', `Falling back to anthropic/opus — reason: ${reason}`);
     if (providerMod && providerMod.getActiveName() !== 'anthropic') {
       providerMod.setActive('anthropic');
     }
     const cfg = yaml.load(fs.readFileSync(CONFIG_FILE, 'utf8')) || {};
     if (!cfg.daemon) cfg.daemon = {};
-    cfg.daemon.model = 'opus';
+    if (!cfg.daemon.models) cfg.daemon.models = {};
+    cfg.daemon.models.claude = 'opus';
+    if (boundProjectKey && cfg.projects && cfg.projects[boundProjectKey]) {
+      cfg.projects[boundProjectKey].model = 'opus';
+    }
     writeConfigSafe(cfg);
     return loadConfig();
   }
@@ -2269,7 +2270,7 @@ ${mentorRadarHint}
           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}`);
+              config = fallbackToDefaultProvider(`output looks like error for ${activeProvCheck}/${model}`, boundProjectKey || '');
               await bot.sendMessage(chatId, `⚠️ ${activeProvCheck}/${model} 疑似失败，已回退到 anthropic/opus\n输出: ${output.slice(0, 150)}`);
             } catch (fbErr) {
               log('ERROR', `Fallback failed: ${fbErr.message}`);
@@ -2500,7 +2501,7 @@ ${mentorRadarHint}
             const builtinModelValues = (ENGINE_MODEL_CONFIG.claude.options || []).map(o => typeof o === 'string' ? o : o.value);
             if ((activeProv !== 'anthropic' || !builtinModelValues.includes(model)) && !errMsg.includes('Stopped by user')) {
               try {
-                config = fallbackToDefaultProvider(`${activeProv}/${model} error: ${errMsg.slice(0, 100)}`);
+                config = fallbackToDefaultProvider(`${activeProv}/${model} error: ${errMsg.slice(0, 100)}`, boundProjectKey || '');
                 await bot.sendMessage(chatId, `⚠️ ${activeProv}/${model} 失败，已回退到 anthropic/opus\n原因: ${errMsg.slice(0, 100)}`);
               } catch (fallbackErr) {
                 log('ERROR', `Fallback failed: ${fallbackErr.message}`);

package/scripts/daemon-command-router.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { resolveEngineModel } = require('./daemon-engine-runtime');
+
 function createCommandRouter(deps) {
   const {
     loadState,
@@ -657,7 +659,7 @@ function createCommandRouter(deps) {
     }
 
     if (text.startsWith('/')) {
-      const currentModel = (config.daemon && config.daemon.model) || 'opus';
+      const currentModel = resolveEngineModel('claude', (config && config.daemon) || {});
       const currentProvider = providerMod ? providerMod.getActiveName() : 'anthropic';
       await bot.sendMessage(chatId, [
         '📱 手机端 Claude Code',

package/scripts/daemon-engine-runtime.js

@@ -93,23 +93,58 @@ const BUILTIN_CLAUDE_MODEL_VALUES = Object.freeze(
   ).filter(Boolean)
 );
 
+function normalizeClaudeModel(model, fallback = ENGINE_MODEL_CONFIG.claude.main) {
+  const raw = String(model || '').trim();
+  if (!raw) return fallback;
+  const normalized = raw.toLowerCase();
+  if (BUILTIN_CLAUDE_MODEL_VALUES.includes(normalized)) return normalized;
+  if (normalized.includes('opus')) return 'opus';
+  if (normalized.includes('sonnet')) return 'sonnet';
+  if (normalized.includes('haiku')) return 'haiku';
+  return fallback;
+}
+
+function looksLikeCodexModel(model) {
+  const raw = String(model || '').trim().toLowerCase();
+  if (!raw) return false;
+  return (
+    raw.startsWith('gpt-')
+    || raw.startsWith('o1')
+    || raw.startsWith('o3')
+    || raw.startsWith('o4')
+    || raw.includes('codex')
+  );
+}
+
 function resolveEngineModel(engineName, daemonCfg = {}, overrideModel = '') {
   const engine = normalizeEngineName(engineName);
   const engineCfg = ENGINE_MODEL_CONFIG[engine] || ENGINE_MODEL_CONFIG.claude;
   const engineModels = (daemonCfg && daemonCfg.models) || {};
   const explicitModel = String(overrideModel || '').trim();
-  if (explicitModel) return explicitModel;
+  if (explicitModel) {
+    return engine === 'claude'
+      ? normalizeClaudeModel(explicitModel, engineCfg.main)
+      : explicitModel;
+  }
 
   const perEngineModel = String(engineModels[engine] || '').trim();
-  if (perEngineModel) return perEngineModel;
+  if (perEngineModel) {
+    return engine === 'claude'
+      ? normalizeClaudeModel(perEngineModel, engineCfg.main)
+      : perEngineModel;
+  }
 
   const legacyModel = String((daemonCfg && daemonCfg.model) || '').trim();
   if (!legacyModel) return engineCfg.main;
 
   // Legacy daemon.model historically meant a Claude model.
-  // Preserve backward compatibility for non-Claude custom model IDs,
-  // but do not leak Claude aliases like "opus" into Codex sessions.
-  if (engine === 'codex' && BUILTIN_CLAUDE_MODEL_VALUES.includes(legacyModel)) {
+  if (engine === 'claude') {
+    return normalizeClaudeModel(legacyModel, engineCfg.main);
+  }
+
+  // Legacy daemon.model primarily belonged to Claude; only reuse it for Codex
+  // when it already looks like a real Codex/OpenAI model id.
+  if (engine === 'codex' && !looksLikeCodexModel(legacyModel)) {
     return engineCfg.main;
   }
   return legacyModel;
@@ -420,6 +455,7 @@ module.exports = {
   resolveBinary,
   detectDefaultEngine,
   resolveEngineModel,
+  normalizeClaudeModel,
   ENGINE_MODEL_CONFIG,
   ENGINE_DISTILL_MAP,
   ENGINE_DEFAULT_MODEL,
@@ -434,5 +470,7 @@ module.exports = {
     normalizeCodexApprovalPolicy,
     resolveCodexPermissionProfile,
     BUILTIN_CLAUDE_MODEL_VALUES,
+    normalizeClaudeModel,
+    looksLikeCodexModel,
   },
 };

package/scripts/daemon-session-store.js

@@ -296,7 +296,9 @@ function createSessionStore(deps) {
               }
             } catch {}
           }
-        } catch { /* skip */ }
+        } catch (err) {
+          log('WARN', `scanClaudeSessions project ${proj}: ${err.message}`);
+        }
 
         try {
           const files = fs.readdirSync(projDir).filter(f => f.endsWith('.jsonl'));
@@ -318,7 +320,9 @@ function createSessionStore(deps) {
               });
             }
           }
-        } catch { /* skip */ }
+        } catch (err) {
+          log('WARN', `scanClaudeSessions project ${proj}: ${err.message}`);
+        }
       }
 
       const all = Array.from(sessionMap.values()).map((entry) => ({ ...entry, engine: 'claude' }));
@@ -385,7 +389,8 @@ function createSessionStore(deps) {
         } catch { /* non-fatal */ }
       }
       return all;
-    } catch {
+    } catch (err) {
+      log('WARN', `scanClaudeSessions: ${err.message}`);
       return [];
     }
   }
@@ -444,8 +449,9 @@ function createSessionStore(deps) {
           };
         })
         .map((session) => enrichCodexSession(session));
-    } catch {
+    } catch (err) {
       if (db) { try { db.close(); } catch { /* ignore */ } }
+      log('WARN', `scanCodexSessions ${CODEX_DB}: ${err.message}`);
       return [];
     }
   }
@@ -544,19 +550,15 @@ function createSessionStore(deps) {
 
   function scanAllSessions() {
     if (_sessionCache && (Date.now() - _sessionCacheTime < SESSION_CACHE_TTL)) return _sessionCache;
-    try {
-      const all = [...scanClaudeSessions(), ...scanCodexSessions()];
-      all.sort((a, b) => {
-        const aTime = a.fileMtime || new Date(a.modified).getTime();
-        const bTime = b.fileMtime || new Date(b.modified).getTime();
-        return bTime - aTime;
-      });
-      _sessionCache = all;
-      _sessionCacheTime = Date.now();
-      return all;
-    } catch {
-      return [];
-    }
+    const all = [...scanClaudeSessions(), ...scanCodexSessions()];
+    all.sort((a, b) => {
+      const aTime = a.fileMtime || new Date(a.modified).getTime();
+      const bTime = b.fileMtime || new Date(b.modified).getTime();
+      return bTime - aTime;
+    });
+    _sessionCache = all;
+    _sessionCacheTime = Date.now();
+    return all;
   }
 
   function listRecentSessions(limit, cwd, engine) {
@@ -1033,10 +1035,6 @@ function createSessionStore(deps) {
 
       // Try to read cwd/model from session JSONL file content (most reliable)
       const metadata = _readClaudeSessionMetadata(sessionFile);
-      if (metadata.model && !metadata.model.startsWith('claude-')) {
-        log('WARN', `[SessionValid] ${sessionId.slice(0, 8)}: non-claude model "${metadata.model}"`);
-        return false;
-      }
       if (metadata.cwd && path.resolve(metadata.cwd) === normCwd) return true;
       if (metadata.cwd) {
         // CWD mismatch: the session was created for a different directory.

package/scripts/daemon-task-scheduler.js

@@ -2,6 +2,7 @@
 
 const crypto = require('crypto');
 const { classifyTaskUsage } = require('./usage-classifier');
+const { resolveEngineModel } = require('./daemon-engine-runtime');
 
 const WEEKDAY_INDEX = Object.freeze({
   sun: 0,
@@ -579,7 +580,7 @@ function createTaskScheduler(deps) {
     if (steps.length === 0) return { success: false, error: 'No steps defined', output: '' };
 
     // Workflow tasks match the user's session model setting (same quality as interactive)
-    const sessionModel = (config && config.daemon && config.daemon.model) || 'sonnet';
+    const sessionModel = resolveEngineModel('claude', (config && config.daemon) || {});
     const model = normalizeModel(task.model || sessionModel);
     const cwd = task.cwd ? task.cwd.replace(/^~/, HOME) : HOME;
     const sessionId = crypto.randomUUID();

package/scripts/daemon.js

@@ -2078,16 +2078,6 @@ if (providerMod && typeof providerMod.setEngine === 'function') {
 }
 log('INFO', `Default engine: ${_defaultEngine} (detected: ${detectedEngine})`);
 
-// One-time migration: daemon.model (legacy) → daemon.models.<engine>
-try {
-  const _migCfg = yaml.load(fs.readFileSync(CONFIG_FILE, 'utf8')) || {};
-  if (_migCfg.daemon && _migCfg.daemon.model && !_migCfg.daemon.models) {
-    _migCfg.daemon.models = { [_defaultEngine]: _migCfg.daemon.model };
-    writeConfigSafe(_migCfg);
-    log('INFO', `Migrated daemon.model="${_migCfg.daemon.model}" → daemon.models.${_defaultEngine}`);
-  }
-} catch { /* ignore */ }
-
 function getDefaultEngine() {
   return _defaultEngine;
 }
@@ -2107,15 +2097,6 @@ function setDefaultEngine(engine) {
       try { providerMod.setEngine(engine); } catch { /* ignore */ }
     }
   }
-  // Migrate old daemon.model → daemon.models[engine] on first switch
-  try {
-    const cfg = yaml.load(fs.readFileSync(CONFIG_FILE, 'utf8')) || {};
-    if (!cfg.daemon) cfg.daemon = {};
-    if (cfg.daemon.model && !cfg.daemon.models) {
-      cfg.daemon.models = { [engine]: cfg.daemon.model };
-      writeConfigSafe(cfg);
-    }
-  } catch { /* ignore */ }
 }
 
 const getEngineRuntime = createEngineRuntimeFactory({
@@ -2609,10 +2590,6 @@ async function main() {
     'enable_nl_mac_control',
     'enable_nl_mac_fallback',
   ];
-  // All known models across all engines (for legacy daemon.model validation only)
-  const BUILTIN_CLAUDE_MODELS = (ENGINE_MODEL_CONFIG.claude.options || []).map(option =>
-    typeof option === 'string' ? option : option.value
-  ).filter(Boolean);
   for (const key of Object.keys(config)) {
     if (!KNOWN_SECTIONS.includes(key)) log('WARN', `Config: unknown section "${key}" (typo?)`);
   }
@@ -2620,14 +2597,11 @@ async function main() {
     for (const key of Object.keys(config.daemon)) {
       if (!KNOWN_DAEMON.includes(key)) log('WARN', `Config: unknown daemon.${key} (typo?)`);
     }
-    // Validate legacy daemon.model (only warn if anthropic provider + unknown Claude model)
-    if (config.daemon.model && !BUILTIN_CLAUDE_MODELS.includes(config.daemon.model)) {
+    // Keep legacy daemon.model read-compatible, but never auto-migrate or treat it
+    // as the write source of truth. The canonical writable field is daemon.models.<engine>.
+    if (config.daemon.model) {
       const activeProv = providerMod ? providerMod.getActiveName() : 'anthropic';
-      if (activeProv === 'anthropic' && _defaultEngine === 'claude') {
-        log('WARN', `Config: daemon.model="${config.daemon.model}" is not a known Claude model`);
-      } else {
-        log('INFO', `Config: legacy daemon.model="${config.daemon.model}" retained; active ${_defaultEngine} model resolves to "${resolveEngineModel(_defaultEngine, config.daemon)}" (${activeProv})`);
-      }
+      log('INFO', `Config: legacy daemon.model detected; active ${_defaultEngine} model resolves to "${resolveEngineModel(_defaultEngine, config.daemon)}" (${activeProv})`);
     }
   }