evolcore 0.0.32 → 0.0.34

package/CHANGELOG.md

@@ -5,6 +5,67 @@
 
 ## Unreleased
 
+## 0.0.34 (2026-10-18)
+
+### 模型与上下文
+
+- 统一 Claude Code、Codex 和 ecagent 的模型参数解析与上下文窗口统计，减少执行窗口、压缩阈值和用量展示之间的不一致。
+- Claude Code 和 ecagent 按模型参数表应用上下文窗口与输出上限；Codex 优先使用 app-server 提供的实时窗口，缺失时仅补充统计信息，不虚构执行窗口。
+- 统一模型窗口后缀、模型参数覆盖和查询/压缩路径的处理，支持新模型参数在不修改 runner 代码的情况下生效。
+
+### 会话与工具
+
+- 完善 Codex 排队任务取消及中断后的状态核验，避免停止操作影响错误轮次。
+- 改进 Shell 工具结果处理，分别保留实际退出码、原始输出和错误摘要，避免将普通输出误当作失败原因。
+- 新增任务授权与会话凭据生命周期诊断，提供可追踪的失效原因和事件信息。
+- 闲置巡检覆盖私聊与群聊，开启前校验必要配置，仅针对未完成且停滞的事项推进或提醒。
+- 补充任务运行结果的结构化错误类型、终止原因和原始诊断信息，区分超时、输出上限、协议不完整及目标会话丢失等终态。
+
+### 错误反馈与运行稳定性
+
+- 细化 AUN 错误反馈展示，保留原始错误详情并避免将未知 403 错误套用无差别的重试或“API 访问受限”提示。
+- 对客户端过旧、积分不足、团队上下文超限等已知 403 原因提供针对性提示；未知原因保留诊断信息并停止自动猜测。
+- 支持目标会话丢失、触发器超时和输出上限等错误在消息协议中携带稳定的 `subtype` 与 `reason`。
+- 抑制 CLI 子进程的 Node.js 实验性 SQLite 警告，减少正常命令输出噪声。
+- 支持创建 AID 时明确登记主体类型，避免身份类型缺失。
+
+### 管理与发布
+
+- 支持同时具备目标 Agent Owner 与 Daemon Owner 身份的用户，通过菜单配置 Agent Fullaccess。
+- Trigger 创建支持填写说明，并在列表和详情中展示。
+- 优化 Windows 进程探测与启动、停止速度，修正 Node 路径识别，并统一 Claude 可用性检测与实际执行程序。
+- 统一列表类命令参数的解析，减少 PowerShell 下逗号分隔参数与审批校验不一致的问题。
+- 升级 AUN SDK 至 `0.5.20`，并收紧 npm 包发布内容，避免将内部文件完整性写入模块打入发行包。
+
+### 兼容性调整
+
+- 首次设定的协作交接统一写入 `persona.md`；`personal.md` 不再自动注入上下文。
+- 移除 `ec memory feedback` 命令，整理反馈改由专用会话按任务要求写入反馈文件。
+
+## 0.0.33 (2026-10-15)
+
+### 话题与会话
+
+- 新增话题管理与跨话题协作，支持查询历史、维护摘要和状态、删除与恢复话题，并通过定时复查跟进跨话题消息。
+- 新增当前主会话和话题的闲置触发设置，可通过聊天命令或菜单单独开启、关闭和调整等待时间。
+- 支持按会话编号查找本地存档，完善话题上下文衔接和后台会话清理。
+- 改进消息中断与任务恢复，避免已提交输入重复执行或未提交输入丢失。
+- 优化后台任务与子智能体的状态展示，将关联任务结果合并到原工具卡片，减少重复提示，并正确展示耗时及完成、失败、停止等状态。
+
+### Agent 与模型
+
+- 简化首次设定：沿用已有有效资料，仅确认缺失、歧义或新增内容；人格和头像可稍后完善，正式欢迎文案由 Agent 自主准备。
+- 完善模型推理强度选项，在模型目录未提供能力信息时按基座支持范围提供选项，并统一角色与关系设置。
+- 强化 Codex 安装与启动检查，支持修复失效绑定，切换到另一套有效安装路径前要求明确确认。
+- 改进 Codex 工具结果诊断，区分策略拒绝、用户拒绝和实际执行结果，减少错误归因。
+
+### 权限与运行稳定性
+
+- 强化受管命令、话题操作及个人和群文件访问的身份与目标校验，发送被拒时提供更明确的原因。
+- 无人值守任务不再请求交互审批，任务恢复与跨会话交接沿用原有审批策略。
+- 查看任务运行上下文不再消耗一次性授权，避免后续操作重复审批。
+- 修复重启提示被恢复后的进程重复投递的问题，并在无法判断错误原因时保留原始诊断信息。
+
 ## 0.0.32 (2026-10-12)
 
 - 统一受管命令的原始参数与审批哈希校验，按会话项目目录解析 Agent 初始化、人格和头像文件，强化授权后的文件访问边界。

package/bin/ec.js

@@ -11,6 +11,7 @@ const repoRoot = path.resolve(here, '..');
 const srcEntry = path.join(repoRoot, 'src', 'cli', 'index.ts');
 const distEntry = path.join(repoRoot, 'dist', 'cli', 'index.js');
 const args = process.argv.slice(2);
+const nodeOptions = ['--no-warnings=ExperimentalWarning'];
 
 // tsx derives its cache directory from `process.geteuid()` on POSIX and
 // `os.userInfo()` on Windows. In managed Windows sessions the latter can
@@ -26,13 +27,13 @@ if (fs.existsSync(srcEntry)) {
     const imports = tsxWindowsCompatImport
       ? ['--import', tsxWindowsCompatImport, '--import', tsxImport]
       : ['--import', tsxImport];
-    const result = spawnSync(process.execPath, [...imports, srcEntry, ...args], { stdio: 'inherit' });
+    const result = spawnSync(process.execPath, [...nodeOptions, ...imports, srcEntry, ...args], { stdio: 'inherit' });
     process.exit(result.status ?? (result.error ? 1 : 0));
   } catch {}
 }
 
 if (fs.existsSync(distEntry)) {
-  const result = spawnSync(process.execPath, [distEntry, ...args], { stdio: 'inherit' });
+  const result = spawnSync(process.execPath, [...nodeOptions, distEntry, ...args], { stdio: 'inherit' });
   process.exit(result.status ?? (result.error ? 1 : 0));
 }
 

package/bin/install-codex-managed-hooks.mjs

@@ -3,7 +3,7 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { isDeepStrictEqual } from 'node:util';
@@ -285,8 +285,66 @@ export function samePackageRoot(embedded, expected) {
   return normalize(embedded) === normalize(expected) || resolved(embedded) === resolved(expected);
 }
 
+// Windows accepts an executable path without its `.exe` suffix. Keep an older
+// `...\\node` binding from being treated as a different runtime than
+// `...\\node.exe` during installer verification.
+function sameRuntimePath(embedded, expected) {
+  if (samePackageRoot(embedded, expected)) return true;
+  if (process.platform !== 'win32' || !embedded) return false;
+  const appendExe = value => path.extname(value) ? value : `${value}.exe`;
+  return samePackageRoot(appendExe(embedded), expected)
+    || samePackageRoot(embedded, appendExe(expected));
+}
+
+function normalizedPath(value) {
+  return path.normalize(String(value || '')).replace(/[\\/]+$/, '').toLowerCase();
+}
+
+function parseManagedCommand(value, hookPath) {
+  if (typeof value !== 'string') return null;
+  const match = /^"([^"\r\n]+)"\s+"([^"\r\n]+)"\s+%EVOLCORE_INSTANCE_SOCKET%$/i.exec(value.trim());
+  if (!match) return null;
+  const nodePath = match[1];
+  const commandHookPath = match[2];
+  if (!path.isAbsolute(nodePath) || /[%!]/.test(nodePath + commandHookPath)) return null;
+  if (normalizedPath(commandHookPath) !== normalizedPath(hookPath)) return null;
+  return { nodePath };
+}
+
+function runtimeFileMayExist(file) {
+  try { return fs.statSync(file).isFile(); }
+  catch (error) { return !['ENOENT', 'ENOTDIR'].includes(error?.code); }
+}
+
+export function managedBinding(source, launcher, hookPath) {
+  const embeddedPackageRoot = launcherPackageRoot(launcher);
+  if (!embeddedPackageRoot || !path.isAbsolute(embeddedPackageRoot)
+    || launcher.replaceAll('\r\n', '\n') !== managedHookLauncher(embeddedPackageRoot)) return null;
+  const retained = removeManagedBlock(source);
+  if (retained === source) return null;
+  const original = parseToml(source);
+  const retainedConfig = parseToml(retained);
+  const groups = original.hooks?.PreToolUse;
+  const retainedGroups = retainedConfig.hooks?.PreToolUse || [];
+  const owned = groups.filter(group => !retainedGroups.some(other => isDeepStrictEqual(group, other)));
+  if (owned.length !== 1) return null;
+  const group = owned[0];
+  if (group.matcher !== '*' || !Array.isArray(group.hooks) || group.hooks.length !== 1) return null;
+  const handler = group.hooks[0];
+  if (handler.type !== 'command' || handler.async === true) return null;
+  const command = parseManagedCommand(handler.command, hookPath);
+  const windowsCommand = parseManagedCommand(handler.command_windows, hookPath);
+  if (!command || !windowsCommand || normalizedPath(command.nodePath) !== normalizedPath(windowsCommand.nodePath)) return null;
+  if (!isDeepStrictEqual(group, { matcher: '*', hooks: [{
+    type: 'command', command: handler.command, command_windows: handler.command_windows,
+    statusMessage: 'Checking EvolCore session policy',
+  }] })) return null;
+  if (retainedGroups.some(other => JSON.stringify(other).toLowerCase().includes('pre-tool-use.mjs'))) return null;
+  return { embeddedPackageRoot, managedNodePath: command.nodePath };
+}
+
 /** Inspect only the canonical EvolCore managed-hook targets. */
-export function inspectManagedHookInstallation({ requirements, managedDir, packageRoot }) {
+export function inspectManagedHookInstallation({ requirements, managedDir, packageRoot, nodePath = process.execPath }) {
   const canonicalRequirements = path.resolve(requirements);
   const canonicalManagedDir = path.resolve(managedDir);
   const hookPath = path.join(canonicalManagedDir, 'pre-tool-use.mjs');
@@ -297,11 +355,12 @@ export function inspectManagedHookInstallation({ requirements, managedDir, packa
         return { status: 'unsafe', requirements: canonicalRequirements, managedDir: canonicalManagedDir, hookPath, reason: `${directory} must be a real directory` };
       }
     } catch (error) {
-      if (error?.code !== 'ENOENT') return { status: 'unsafe', requirements: canonicalRequirements, managedDir: canonicalManagedDir, hookPath, reason: error?.message || String(error) };
+      if (error?.code !== 'ENOENT') return { status: 'unavailable', requirements: canonicalRequirements, managedDir: canonicalManagedDir, hookPath, reason: error?.message || String(error) };
     }
   }
   const req = regularFile(canonicalRequirements);
   const hook = regularFile(hookPath);
+  if (req.error || hook.error) return { status: 'unavailable', requirements: canonicalRequirements, managedDir: canonicalManagedDir, hookPath, reason: 'unable to inspect requirements or launcher' };
   if (req.unsafe || hook.unsafe) return { status: 'unsafe', requirements: canonicalRequirements, managedDir: canonicalManagedDir, hookPath, reason: 'requirements or launcher is not a regular file' };
   if (!req.ok && hook.ok) return { status: 'unsafe', requirements: canonicalRequirements, managedDir: canonicalManagedDir, hookPath, reason: 'canonical launcher exists but requirements.toml is missing' };
   if (req.ok && !hook.ok) {
@@ -324,48 +383,81 @@ export function inspectManagedHookInstallation({ requirements, managedDir, packa
     }
   }
   if (!req.ok || !hook.ok) return { status: 'missing', requirements: canonicalRequirements, managedDir: canonicalManagedDir, hookPath, reason: 'requirements or launcher is missing' };
-  let parsed;
-  try { parsed = parseToml(fs.readFileSync(canonicalRequirements, 'utf8')); }
-  catch (error) { return { status: 'unsafe', requirements: canonicalRequirements, managedDir: canonicalManagedDir, hookPath, reason: `requirements.toml is invalid: ${error?.message || String(error)}` }; }
-  const configured = parsed.hooks?.windows_managed_dir ?? parsed.hooks?.managed_dir;
-  const normalized = value => path.normalize(String(value || '')).toLowerCase();
-  const launcher = fs.readFileSync(hookPath, 'utf8');
-  const packageMarker = launcher.includes('EVOLCORE_MANAGED_HOOK_LAUNCHER')
-    && samePackageRoot(launcherPackageRoot(launcher), path.resolve(packageRoot || process.cwd()));
-  const preToolUse = parsed.hooks?.PreToolUse;
-  const canonicalCommand = value => {
-    if (typeof value !== 'string' || !value || /[\r\n;&|<>]/.test(value)) return false;
-    const withoutSocket = value.replace(/\s+%EVOLCORE_INSTANCE_SOCKET%\s*$/i, '').trim();
-    return withoutSocket.replace(/["']+$/, '').toLowerCase().endsWith(normalized(hookPath));
-  };
-  const loaded = Array.isArray(preToolUse) && preToolUse.some(group => group?.matcher === '*'
-    && Array.isArray(group.hooks) && group.hooks.some(handler => handler?.type === 'command'
-      && handler.async !== true && typeof handler.command === 'string'
-      && canonicalCommand(handler.command)
-      && canonicalCommand(handler.command_windows ?? handler.commandWindows)));
-  const valid = parsed.allow_managed_hooks_only === true
-    && parsed.features?.hooks === true
-    && normalized(configured) === normalized(canonicalManagedDir)
-    && packageMarker && loaded;
-  return valid
-    ? { status: 'installed', requirements: canonicalRequirements, managedDir: canonicalManagedDir, hookPath }
-    : { status: 'unsafe', requirements: canonicalRequirements, managedDir: canonicalManagedDir, hookPath, reason: 'managed-hook policy is missing, altered, or points outside the canonical target' };
-}
-
-/** Idempotently repair a missing canonical installation; unsafe edits fail closed. */
+  let source;
+  let launcher;
+  try {
+    source = fs.readFileSync(canonicalRequirements, 'utf8');
+    launcher = fs.readFileSync(hookPath, 'utf8');
+  } catch (error) {
+    return { status: 'unavailable', requirements: canonicalRequirements, managedDir: canonicalManagedDir, hookPath, reason: error?.message || String(error) };
+  }
+  try {
+    const parsed = parseToml(source);
+    const binding = managedBinding(source, launcher, hookPath);
+    if (!binding || parsed.allow_managed_hooks_only !== true || parsed.features?.hooks !== true
+      || normalizedPath(parsed.hooks?.windows_managed_dir) !== normalizedPath(canonicalManagedDir)
+      || (parsed.hooks?.managed_dir !== undefined
+        && normalizedPath(parsed.hooks.managed_dir) !== normalizedPath(canonicalManagedDir))) {
+      throw new Error('managed-hook policy is missing, altered, or points outside the canonical target');
+    }
+    const { embeddedPackageRoot, managedNodePath } = binding;
+    const packageMatches = samePackageRoot(embeddedPackageRoot, path.resolve(packageRoot || process.cwd()));
+    const nodeMatches = sameRuntimePath(managedNodePath, nodePath);
+    const state = {
+      requirements: canonicalRequirements, managedDir: canonicalManagedDir, hookPath,
+      managedPackageRoot: embeddedPackageRoot, managedNodePath,
+      repairFingerprint: createHash('sha256').update(source).update('\0').update(launcher).digest('hex'),
+    };
+    if (packageMatches && nodeMatches) return { ...state, status: 'installed' };
+    return {
+      ...state, status: 'stale',
+      repairAmbiguous: runtimeFileMayExist(path.join(embeddedPackageRoot, 'bin', 'codex-managed-hook.mjs'))
+        && runtimeFileMayExist(managedNodePath),
+      reason: !packageMatches && !nodeMatches
+        ? 'managed-hook points to a different EvolCore package root and Node runtime'
+        : !packageMatches ? 'managed-hook points to a different EvolCore package root'
+          : 'managed-hook points to a different Node runtime',
+    };
+  } catch (error) {
+    return { status: 'unsafe', requirements: canonicalRequirements, managedDir: canonicalManagedDir, hookPath, reason: error?.message || String(error) };
+  }
+}
+
+/** Idempotently repair a missing or stale canonical installation; unsafe edits fail closed. */
 export function repairManagedHookInstallation(options, acl = windowsAcl) {
   const { requirements, managedDir, packageRoot, nodePath = process.execPath } = options;
   const canonicalRequirements = path.resolve(requirements);
   const canonicalManagedDir = path.resolve(managedDir);
   const hookPath = path.join(canonicalManagedDir, 'pre-tool-use.mjs');
   const sourceHook = path.join(packageRoot, 'bin', 'codex-managed-hook.mjs');
-  const state = inspectManagedHookInstallation({ requirements: canonicalRequirements, managedDir: canonicalManagedDir, packageRoot });
+  const state = inspectManagedHookInstallation({ requirements: canonicalRequirements, managedDir: canonicalManagedDir, packageRoot, nodePath });
   if (state.status === 'installed') return { ...state, repaired: false, warnings: [] };
-  if (state.status === 'unsafe') throw new Error(`Refusing automatic managed-hook repair: ${state.reason}`);
+  if (!['missing', 'stale'].includes(state.status)) throw new Error(`Refusing automatic managed-hook repair: ${state.reason}`);
+  if (state.status === 'stale' && (options.expectedFingerprint !== state.repairFingerprint
+    || (state.repairAmbiguous && options.confirmRebind !== true))) {
+    throw new Error('Refusing automatic managed-hook repair: binding changed or requires explicit confirmation');
+  }
   if (!fs.existsSync(sourceHook)) throw new Error(`Required Hook runtime file was not found: ${sourceHook}`);
   const previousContent = fs.existsSync(canonicalRequirements) ? fs.readFileSync(canonicalRequirements, 'utf8') : '';
   const content = buildManagedRequirements(previousContent, { targetDirectory: canonicalManagedDir, nodePath, hookPath });
-  const warnings = provisionManagedFiles({ requirements: canonicalRequirements, hookPath, sourceHook, nodePath, previousContent, content, launcher: managedHookLauncher(packageRoot) }, acl);
+  const inspect = () => inspectManagedHookInstallation({
+    requirements: canonicalRequirements, managedDir: canonicalManagedDir, packageRoot, nodePath,
+  });
+  const warnings = provisionManagedFiles({
+    requirements: canonicalRequirements, hookPath, sourceHook, nodePath, previousContent, content,
+    launcher: managedHookLauncher(packageRoot),
+    beforePublish: () => {
+      const latest = inspect();
+      if (latest.status !== state.status || latest.repairFingerprint !== state.repairFingerprint
+        || latest.repairAmbiguous !== state.repairAmbiguous) {
+        throw new Error('Managed-hook state changed before publication; retry the startup check');
+      }
+    },
+    verifyPublished: () => {
+      const verified = inspect();
+      if (verified.status !== 'installed') throw new Error('Managed-hook verification failed: ' + verified.reason);
+    },
+  }, acl);
   return { status: 'installed', requirements: canonicalRequirements, managedDir: canonicalManagedDir, hookPath, repaired: true, warnings };
 }
 
@@ -475,6 +567,7 @@ export function provisionManagedFiles(options, acl = windowsAcl) {
   let committed = false;
   try {
     fs.writeFileSync(lock, JSON.stringify({ pid: process.pid, started: new Date().toISOString() }));
+    options.beforePublish?.();
     const existing = existingFile(requirements, fs);
     // Detect edits made after configuration generation, including a second
     // installer completing just before this process acquired the lock.
@@ -509,11 +602,13 @@ export function provisionManagedFiles(options, acl = windowsAcl) {
         const target = temporary ? entry.temporary : entry.file;
         if (fs.readFileSync(target, 'utf8') !== entry.value) throw new Error(`Installed content differs: ${target}`);
       }
-      return acl('verify', { entries: [
+      const report = acl('verify', { entries: [
         { path: directory, protected: true, execute: true },
         ...staged.map(entry => ({ path: temporary ? entry.temporary : entry.file, protected: true })),
         ...readable,
       ] });
+      if (temporary === false) options.verifyPublished?.();
+      return report;
     };
     verify(true);
     let accessReport;
@@ -561,7 +656,10 @@ function main() {
     if (!fs.statSync(file).isFile()) fail(`Required Hook runtime file was not found: ${file}`);
   }
   if (hasArgument('--repair')) {
-    const result = repairManagedHookInstallation({ requirements, managedDir: targetDirectory, packageRoot, nodePath });
+    const result = repairManagedHookInstallation({
+      requirements, managedDir: targetDirectory, packageRoot, nodePath,
+      expectedFingerprint: argument('--expected-fingerprint'), confirmRebind: hasArgument('--confirm-rebind'),
+    });
     process.stdout.write(`${JSON.stringify(result)}\n`);
     return;
   }

package/dist/agents/baseagent-availability.js

@@ -1,39 +1,17 @@
 import { normalizeBaseagent } from './baseagent.js';
 import { commandExists } from '../utils/cross-platform.js';
 import { getCodexAppServerAvailability } from './codex-runner.js';
-import { createRequire } from 'module';
-import fs from 'fs';
-import path from 'path';
-const _resolveModule = createRequire(import.meta.url);
+import { probeBundledClaudeVersion, resolveBundledClaudeExecutable } from './claude-runner.js';
 /**
- * Check whether the bundled Claude SDK native binary is present on disk.
- * This covers Windows installations where the npm global shim may be absent
- * but the SDK ships claude.exe alongside evolcore's own node_modules.
+ * Claude 的检测判据就是执行判据：会话只会在 Windows 上跑内置的、与 SDK 锁定版本
+ * 配套的 claude.exe。PATH 里的全局 claude 执行层从不使用，因此不能作为可用判据——
+ * 那个假阳性正是「检测说可用、会话全失败」持续 21 小时没被发现的成因。
  */
-function isBundledClaudeAvailable() {
-    if (process.platform !== 'win32')
-        return false;
-    const nativePackage = process.arch === 'arm64'
-        ? '@anthropic-ai/claude-agent-sdk-win32-arm64'
-        : process.arch === 'x64'
-            ? '@anthropic-ai/claude-agent-sdk-win32-x64'
-            : undefined;
-    if (!nativePackage)
-        return false;
-    try {
-        const exe = _resolveModule.resolve(`${nativePackage}/claude.exe`);
-        if (fs.existsSync(exe))
-            return true;
-    }
-    catch { /* fall through */ }
-    try {
-        const sdkEntry = _resolveModule.resolve('@anthropic-ai/claude-agent-sdk');
-        const exe = path.resolve(path.dirname(sdkEntry), '..', '@anthropic-ai', nativePackage.slice('@anthropic-ai/'.length), 'claude.exe');
-        return fs.existsSync(exe);
-    }
-    catch {
-        return false;
-    }
+function claudeExecutable() {
+    if (process.platform === 'win32')
+        return resolveBundledClaudeExecutable();
+    // 非 Windows 平台由 SDK 自己解析平台包，此处沿用命令探测。
+    return commandExists('claude') ? 'claude' : undefined;
 }
 export const BASEAGENT_CANDIDATES = ['claude', 'codex', 'gemini', 'ecagent'];
 export const AUTO_BASEAGENT_CANDIDATES = ['claude', 'codex', 'gemini'];
@@ -49,19 +27,25 @@ export function detectAvailableBaseagents(codexAvailability = getCodexAppServerA
         if (baseagent === 'codex')
             return codexAvailability.available;
         if (baseagent === 'claude')
-            return commandExists(baseagent) || isBundledClaudeAvailable();
+            return claudeExecutable() !== undefined;
         return commandExists(baseagent);
     });
 }
 export function detectBaseagentDetails(codexAvailability = getCodexAppServerAvailability()) {
-    const claude = commandExists('claude') || isBundledClaudeAvailable();
+    const claude = claudeExecutable();
+    const claudeVersion = claude ? probeBundledClaudeVersion() : undefined;
     const gemini = commandExists('gemini');
     return [
         {
             id: 'claude',
-            detected: claude,
-            detectionSource: claude ? ['PATH'] : [],
-            reason: claude ? undefined : '未检测到 Claude CLI。',
+            detected: claude !== undefined,
+            detectionSource: claude ? [process.platform === 'win32' ? 'bundled SDK binary' : 'PATH'] : [],
+            reason: claude
+                ? undefined
+                : process.platform === 'win32'
+                    ? '未找到内置 claude.exe（@anthropic-ai/claude-agent-sdk-win32-x64）。请重新安装 SDK 的平台包。'
+                    : '未检测到 Claude CLI。',
+            version: claudeVersion,
         },
         {
             id: 'codex',