@cicctencent/agent-core 0.1.1 → 0.1.4

package/src/security/types.ts

@@ -1,46 +0,0 @@
-// ============================================================
-// Security Guard 类型定义
-// ============================================================
-
-// ---- SanitizeResult ----
-
-export type Severity = 'safe' | 'warn' | 'danger' | 'blocked';
-
-export interface SanitizeResult {
-  /** 是否允许执行 */
-  safe: boolean;
-  /** 改写后的命令（如 rm → mv 到回收站） */
-  rewritten?: string;
-  /** 拒绝/警告原因 */
-  reason?: string;
-  /** 严重程度 */
-  severity: Severity;
-}
-
-// ---- SecurityRule / SecurityPolicy ----
-
-export interface SecurityRule {
-  /** 规则名称 */
-  name: string;
-  /** 匹配模式（正则或函数） */
-  pattern: RegExp | ((command: string) => boolean);
-  /** 命中后的严重程度 */
-  severity: Severity;
-  /** 命中后的处理：'block' 阻止 | 'rewrite' 改写 | 'warn' 放行但记录 */
-  action: 'block' | 'rewrite' | 'warn';
-  /** 改写函数（action='rewrite' 时使用） */
-  rewriter?: (command: string) => string;
-  /** 规则描述 */
-  description?: string;
-}
-
-export interface SecurityPolicy {
-  /** 是否启用删除保护（rm → mv 到回收站） */
-  deleteProtection: boolean;
-  /** 回收站路径 */
-  trashDir: string;
-  /** 是否启用黑名单 */
-  blacklistEnabled: boolean;
-  /** 自定义规则 */
-  rules: SecurityRule[];
-}

package/src/skill/manager.ts

@@ -1,420 +0,0 @@
-// ============================================================
-// SkillManager — Skill 懒加载 / 解析 / 管理
-// ============================================================
-
-import * as fs from 'fs';
-import * as path from 'path';
-import type { Skill, SkillManifest, SkillSource } from './types.ts';
-
-/** 简单 LRU 缓存（基于 Map 插入顺序） */
-class LRUCache<V> {
-  private cache = new Map<string, V>();
-  private max: number;
-
-  constructor(max: number) {
-    this.max = max;
-  }
-
-  get(key: string): V | undefined {
-    const val = this.cache.get(key);
-    if (val !== undefined) {
-      // 移到末尾（最近使用）
-      this.cache.delete(key);
-      this.cache.set(key, val);
-    }
-    return val;
-  }
-
-  set(key: string, value: V): void {
-    if (this.cache.has(key)) {
-      this.cache.delete(key);
-    } else if (this.cache.size >= this.max) {
-      // 删除最旧的（Map 的第一个 key）
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey !== undefined) this.cache.delete(firstKey);
-    }
-    this.cache.set(key, value);
-  }
-
-  has(key: string): boolean {
-    return this.cache.has(key);
-  }
-
-  delete(key: string): void {
-    this.cache.delete(key);
-  }
-
-  clear(): void {
-    this.cache.clear();
-  }
-
-  get size(): number {
-    return this.cache.size;
-  }
-}
-
-/** 懒加载配置 */
-interface LazyLoadConfig {
-  /** content LRU 缓存容量（默认 30） */
-  cacheSize?: number;
-  /** 是否在启动时就加载 content（false=懒加载，默认 true 保持向后兼容） */
-  lazy?: boolean;
-}
-
-export class SkillManager {
-  /** 轻量清单索引（仅 front matter，不含 content） */
-  private manifests = new Map<string, SkillManifest>();
-  /** content LRU 缓存（懒加载时按需填充） */
-  private contentCache: LRUCache<string>;
-  /** 是否启用懒加载 */
-  private lazy: boolean;
-  /** 记录加载的目录，用于 reload */
-  private loadedDirs: Array<{ dir: string; source: SkillSource; connectorId?: string }> = [];
-
-  constructor(config?: LazyLoadConfig) {
-    this.contentCache = new LRUCache(config?.cacheSize ?? 30);
-    this.lazy = config?.lazy ?? false;
-  }
-
-  /**
-   * 将连接器 ID 和 Skill ID 拼接为内部存储 key
-   * 格式：`{connectorId}__{skillId}`
-   */
-  static connectorSkillKey(connectorId: string, skillId: string): string {
-    return `${connectorId}__${skillId}`;
-  }
-
-  /**
-   * 拆分连接器 Skill key，返回 [connectorId, skillId]，无连接器则返回 null
-   */
-  static splitConnectorSkillKey(key: string): [string, string] | null {
-    const idx = key.indexOf('__');
-    if (idx <= 0) return null;
-    return [key.substring(0, idx), key.substring(idx + 2)];
-  }
-
-  /**
-   * 从目录加载 Skill 文件
-   *
-   * - lazy=true：仅解析 front matter（manifest），不读 content，毫秒级完成
-   * - lazy=false（默认）：全量读取，保持向后兼容
-   */
-  loadFromDir(dir: string, source: SkillSource, connectorId?: string): void {
-    this.loadedDirs.push({ dir, source, connectorId });
-
-    const resolvedDir = dir.startsWith('~')
-      ? path.join(process.env.HOME || '', dir.slice(1))
-      : path.resolve(dir);
-
-    if (!fs.existsSync(resolvedDir)) return;
-
-    const files = fs.readdirSync(resolvedDir);
-    for (const file of files) {
-      if (!file.endsWith('.md')) continue;
-      const baseId = path.basename(file, '.md');
-      const filePath = path.join(resolvedDir, file);
-      const storageId = connectorId
-        ? SkillManager.connectorSkillKey(connectorId, baseId)
-        : baseId;
-
-      if (this.lazy) {
-        // 懒加载模式：仅解析 front matter，不读 content
-        const manifest = this.parseManifest(baseId, filePath, source, connectorId);
-        if (manifest) {
-          this.manifests.set(storageId, manifest);
-        }
-      } else {
-        // 兼容模式：全量读取（保持原有行为）
-        const raw = fs.readFileSync(filePath, 'utf-8');
-        const skill = this.parse(baseId, raw, source);
-        if (connectorId) {
-          skill.metadata = { ...skill.metadata, connectorId };
-        }
-        this.manifests.set(storageId, this.toManifest(skill, filePath));
-        this.contentCache.set(storageId, skill.content);
-      }
-    }
-  }
-
-  /** 手动注册 Skill（全量，含 content） */
-  register(skill: Skill): void {
-    this.manifests.set(skill.id, this.toManifest(skill));
-    if (skill.content) {
-      this.contentCache.set(skill.id, skill.content);
-    }
-  }
-
-  /** 注销 Skill */
-  unregister(id: string): void {
-    this.manifests.delete(id);
-    this.contentCache.delete(id);
-  }
-
-  /**
-   * 获取指定 Skill（含 content）
-   *
-   * - 缓存命中：直接返回
-   * - 缓存未命中 + 有 filePath：从磁盘懒加载 content
-   * - 缓存未命中 + 无 filePath：返回空 content（仅 manifest）
-   */
-  get(id: string): Skill | undefined {
-    const manifest = this.manifests.get(id);
-    if (!manifest) return undefined;
-
-    let content = this.contentCache.get(id);
-    if (content === undefined) {
-      // 懒加载：从磁盘读取 content
-      content = this.loadContent(manifest);
-      if (content) {
-        this.contentCache.set(id, content);
-        // 自动加载引用的 Skills（referencedSkills）
-        this.preloadReferencedSkills(manifest);
-      }
-    }
-
-    return { ...manifest, content: content || '' };
-  }
-
-  /**
-   * 获取 Skill 清单（不含 content，用于路由目录构建和 UI 展示）
-   */
-  getManifest(id: string): SkillManifest | undefined {
-    return this.manifests.get(id);
-  }
-
-  /**
-   * 获取所有 Skill 清单（不含 content）
-   * 适用于 SkillRouter 构建路由目录、Engine 构建 skill catalog、UI 列表展示
-   */
-  getAllManifests(): SkillManifest[] {
-    return [...this.manifests.values()];
-  }
-
-  /** 获取所有已注册 Skill（含 content，触发懒加载） */
-  getAll(): Skill[] {
-    return [...this.manifests.keys()].map(id => this.get(id)!).filter(Boolean);
-  }
-
-  /** 按标签过滤 */
-  getByTag(tag: string): Skill[] {
-    return this.getAll().filter((s) =>
-      s.tags.some((t) => t.toLowerCase() === tag.toLowerCase()),
-    );
-  }
-
-  /** 检查某个目录是否已在加载列表中 */
-  hasLoadedDir(dir: string): boolean {
-    const resolvedDir = dir.startsWith('~')
-      ? path.join(process.env.HOME || '', dir.slice(1))
-      : path.resolve(dir);
-    return this.loadedDirs.some(d => {
-      const existing = d.dir.startsWith('~')
-        ? path.join(process.env.HOME || '', d.dir.slice(1))
-        : path.resolve(d.dir);
-      return existing === resolvedDir;
-    });
-  }
-
-  /** 获取缓存统计信息 */
-  getCacheStats(): { manifestCount: number; cachedContentCount: number; lazyMode: boolean } {
-    return {
-      manifestCount: this.manifests.size,
-      cachedContentCount: this.contentCache.size,
-      lazyMode: this.lazy,
-    };
-  }
-
-  /** 重新加载（文件变更后刷新） */
-  reload(): void {
-    this.manifests.clear();
-    this.contentCache.clear();
-    const dirs = [...this.loadedDirs];
-    this.loadedDirs = [];  // 重置，loadFromDir 会重新填充
-    for (const { dir, source, connectorId } of dirs) {
-      this.loadFromDir(dir, source, connectorId);
-    }
-  }
-
-  // ---- 内部方法 ----
-
-  /**
-   * 从磁盘懒加载 content
-   * 支持 Markdown 文件（含 front matter）和纯文本
-   */
-  private loadContent(manifest: SkillManifest): string {
-    if (!manifest.filePath) return '';
-    try {
-      if (!fs.existsSync(manifest.filePath)) return '';
-      const raw = fs.readFileSync(manifest.filePath, 'utf-8');
-      const normalized = raw.replace(/\r\n/g, '\n');
-      const match = normalized.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-      if (match) {
-        return match[2].trim();
-      }
-      return raw;
-    } catch (err: any) {
-      console.warn(`[SkillManager] Failed to lazy-load content for "${manifest.id}":`, err?.message);
-      return '';
-    }
-  }
-
-  /**
-   * 预加载引用的 Skills（referencedSkills）
-   * 当某个 Skill 被加载时，自动加载它引用的其他 Skills
-   */
-  private preloadReferencedSkills(manifest: SkillManifest): void {
-    if (!manifest.referencedSkills?.length) return;
-    for (const refId of manifest.referencedSkills) {
-      if (!this.contentCache.has(refId)) {
-        const refManifest = this.manifests.get(refId);
-        if (refManifest) {
-          const content = this.loadContent(refManifest);
-          if (content) {
-            this.contentCache.set(refId, content);
-          }
-        }
-      }
-    }
-  }
-
-  /** 从 Skill 对象提取清单（剥离 content） */
-  private toManifest(skill: Skill, filePath?: string): SkillManifest {
-    const { content, ...manifest } = skill;
-    if (filePath) manifest.filePath = filePath;
-    if (!manifest.contentSize && content) {
-      manifest.contentSize = content.length;
-    }
-    return manifest;
-  }
-
-  /**
-   * 仅解析 front matter（不读 content），用于懒加载模式
-   * 通过读取文件前 N 字节提取 YAML front matter，避免加载整个文件
-   */
-  private parseManifest(id: string, filePath: string, source: SkillSource, connectorId?: string): SkillManifest | null {
-    try {
-      // 只读取文件前 2KB 来提取 front matter
-      const fd = fs.openSync(filePath, 'r');
-      const buf = Buffer.alloc(2048);
-      const bytesRead = fs.readSync(fd, buf, 0, 2048, 0);
-      fs.closeSync(fd);
-
-      const head = buf.toString('utf-8', 0, bytesRead);
-      const normalized = head.replace(/\r\n/g, '\n');
-      const match = normalized.match(/^---\n([\s\S]*?)\n---/);
-
-      const fileSize = fs.statSync(filePath).size;
-
-      if (!match) {
-        // 无 front matter，使用文件名作为 name
-        return {
-          id,
-          name: id,
-          description: '',
-          tags: [],
-          aliases: [],
-          source,
-          filePath,
-          contentSize: fileSize,
-          referencedSkills: [],
-          requires: [],
-          ...(connectorId ? { metadata: { connectorId } } : {}),
-        };
-      }
-
-      const fm = match[1];
-      const referencedSkills = this.parseTags(this.extractField(fm, 'referenced_skills') || this.extractField(fm, 'referencedSkills') || '');
-
-      const manifest: SkillManifest = {
-        id,
-        name: this.extractField(fm, 'name') || id,
-        description: this.extractField(fm, 'description') || '',
-        tags: this.parseTags(this.extractField(fm, 'tags') || ''),
-        aliases: this.parseTags(this.extractField(fm, 'aliases') || ''),
-        source,
-        version: this.extractField(fm, 'version') || undefined,
-        author: this.extractField(fm, 'author') || undefined,
-        requires: this.parseTags(this.extractField(fm, 'requires') || ''),
-        referencedSkills: referencedSkills.length > 0 ? referencedSkills : undefined,
-        filePath,
-        contentSize: fileSize,
-        ...(connectorId ? { metadata: { connectorId } } : {}),
-      };
-
-      return manifest;
-    } catch (err: any) {
-      console.warn(`[SkillManager] Failed to parse manifest for "${id}":`, err?.message);
-      return null;
-    }
-  }
-
-  /** 解析完整的 Markdown 文件（含 content），用于兼容模式 */
-  private parse(id: string, raw: string, source: SkillSource): Skill {
-    // 统一行尾为 \n（兼容 Windows CRLF）
-    const normalized = raw.replace(/\r\n/g, '\n');
-    const match = normalized.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-    if (!match) {
-      return {
-        id,
-        name: id,
-        description: '',
-        tags: [],
-        aliases: [],
-        content: raw,
-        source,
-        requires: [],
-      };
-    }
-
-    let frontMatter = match[1];
-    let content = match[2].trim();
-
-    // 检测双重 frontmatter（旧版 createSkillFromFile 产生的问题）
-    const doubleMatch = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-    if (doubleMatch) {
-      const fm1Fields = frontMatter.split('\n').filter(l => /^\w+:/.test(l)).length;
-      const fm2Fields = doubleMatch[1].split('\n').filter(l => /^\w+:/.test(l)).length;
-      if (fm2Fields > fm1Fields) {
-        frontMatter = doubleMatch[1];
-        content = doubleMatch[2].trim();
-      }
-    }
-
-    return {
-      id,
-      name: this.extractField(frontMatter, 'name') || id,
-      description: this.extractField(frontMatter, 'description') || '',
-      tags: this.parseTags(this.extractField(frontMatter, 'tags') || ''),
-      aliases: this.parseTags(this.extractField(frontMatter, 'aliases') || ''),
-      content,
-      source,
-      version: this.extractField(frontMatter, 'version') || undefined,
-      author: this.extractField(frontMatter, 'author') || undefined,
-      requires: this.parseTags(this.extractField(frontMatter, 'requires') || ''),
-      referencedSkills: this.parseReferencedSkills(frontMatter),
-    };
-  }
-
-  /** 解析 referenced_skills 字段 */
-  private parseReferencedSkills(frontMatter: string): string[] | undefined {
-    const raw = this.extractField(frontMatter, 'referenced_skills') || this.extractField(frontMatter, 'referencedSkills') || '';
-    const tags = this.parseTags(raw);
-    return tags.length > 0 ? tags : undefined;
-  }
-
-  private extractField(frontMatter: string, field: string): string {
-    const regex = new RegExp(`^${field}:\\s*(.+)$`, 'm');
-    const match = frontMatter.match(regex);
-    return match ? match[1].trim() : '';
-  }
-
-  private parseTags(raw: string): string[] {
-    // 支持 [tag1, tag2] 和 tag1, tag2 两种格式
-    const cleaned = raw.replace(/^\[|\]$/g, '');
-    if (!cleaned.trim()) return [];
-    return cleaned
-      .split(',')
-      .map((t) => t.trim())
-      .filter(Boolean);
-  }
-}

package/src/skill/router.ts

@@ -1,158 +0,0 @@
-// ============================================================
-// SkillRouter — 三级路由（自定义策略/显式/关键词）
-// ============================================================
-// 未命中时由 Engine 在 system prompt 中注入 skill catalog，
-// Agent 通过 load_skill 工具按需加载，无需独立 LLM 路由调用
-
-import type { Skill, SkillManifest, RouteResult, RouteStrategy } from './types.ts';
-import type { SkillManager } from './manager.ts';
-
-export class SkillRouter {
-  private strategies: RouteStrategy[] = [];
-  private skillManager: SkillManager;
-
-  constructor(skillManager: SkillManager) {
-    this.skillManager = skillManager;
-  }
-
-  /**
-   * 路由：自定义策略 → 显式调用 → 关键词匹配
-   * 命中即停，全部未命中返回 { skill: null }（由 Engine 注入 skill catalog，Agent 自主调用 load_skill）
-   */
-  async route(message: string): Promise<RouteResult> {
-    // 使用 manifests 做路由匹配（避免触发全量懒加载）
-    const manifests = this.skillManager.getAllManifests();
-    if (manifests.length === 0) {
-      return { skill: null, message, matchType: 'explicit', confidence: 0 };
-    }
-  
-    // ① 自定义策略（优先级最高）— 需要全量 Skill，保持兼容
-    const skills = this.skillManager.getAll();
-    for (const strategy of this.strategies) {
-      const result = await strategy.match(message, skills);
-      if (result) return result;
-    }
-  
-    // ② 显式调用（斜杠命令）
-    const explicitResult = this.matchExplicit(message);
-    if (explicitResult) return explicitResult;
-  
-    // ③ 关键词匹配（仅用 manifest，不触发加载）
-    const keywordResult = this.matchByKeywords(message, manifests);
-    if (keywordResult) return keywordResult;
-  
-    // ④ 全部未命中 → Engine 会在 system prompt 注入 skill catalog
-    return { skill: null, message, matchType: 'explicit', confidence: 0 };
-  }
-
-  /** 注册自定义路由策略（优先级高于内置三级路由） */
-  addStrategy(strategy: RouteStrategy): void {
-    this.strategies.push(strategy);
-  }
-
-  /** 移除自定义策略 */
-  removeStrategy(name: string): void {
-    this.strategies = this.strategies.filter((s) => s.name !== name);
-  }
-
-  // ---- 第1级：显式调用（斜杠命令） ----
-
-  private matchExplicit(message: string): RouteResult | null {
-    if (!message.startsWith('/')) return null;
-
-    // 支持两种格式：
-    // 1. /skill-id （公有 Skill 或匹配唯一后缀的连接器 Skill）
-    // 2. /connector-id/skill-id （显式指定连接器的 Skill）
-    const match = message.match(/^\/([a-z0-9_-]+)(?:\/([a-z0-9_-]+))?\s*(.*)/is);
-    if (!match) return null;
-
-    const first = match[1];
-    const second = match[2];
-    const rest = match[3] || '';
-
-    if (second) {
-      // 格式 /connector/skill → 查找连接器前缀 key: {connector}__{skill}
-      const prefixedKey = `${first}__${second}`;
-      const skill = this.skillManager.get(prefixedKey);
-      if (skill) {
-        return { skill, message: rest || skill.description, matchType: 'explicit', confidence: 1 };
-      }
-      return null;
-    }
-
-    // 格式 /skill-id → 先精确匹配，再查找连接器后缀唯一匹配
-    let skill = this.skillManager.get(first);
-    if (skill) {
-      return { skill, message: rest || skill.description, matchType: 'explicit', confidence: 1 };
-    }
-
-    // 尝试后缀匹配：查找 key 以 `__{first}` 结尾的连接器 Skill
-    const suffix = `__${first}`;
-    const allManifests = this.skillManager.getAllManifests();
-    const candidates = allManifests.filter(m => {
-      const key = this.getManifestStorageKey(m);
-      return key.endsWith(suffix);
-    });
-    if (candidates.length === 1) {
-      const storageKey = this.getManifestStorageKey(candidates[0]);
-      const skill = this.skillManager.get(storageKey);
-      if (skill) {
-        return { skill, message: rest || skill.description, matchType: 'explicit', confidence: 1 };
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * 获取 Skill 在 SkillManager 中的存储 key
-   * 通过 metadata.connectorId 判断是否为连接器 Skill
-   */
-  private getSkillStorageKey(skill: Skill): string {
-    const connectorId = skill.metadata?.connectorId as string | undefined;
-    return connectorId ? `${connectorId}__${skill.id}` : skill.id;
-  }
-
-  /** 获取 Manifest 在 SkillManager 中的存储 key（同 getSkillStorageKey，但用 manifest 类型） */
-  private getManifestStorageKey(manifest: SkillManifest): string {
-    const connectorId = manifest.metadata?.connectorId as string | undefined;
-    return connectorId ? `${connectorId}__${manifest.id}` : manifest.id;
-  }
-
-  // ---- 第2级：关键词匹配（保守模式，仅高置信度时命中）----
-
-  private matchByKeywords(message: string, manifests: SkillManifest[]): RouteResult | null {
-    let bestMatch: { manifest: SkillManifest; score: number; coverage: number } | null = null;
-    const lowerMsg = message.toLowerCase();
-
-    for (const manifest of manifests) {
-      // 合并 tags + aliases 作为匹配词库
-      const keywords = [...manifest.tags, ...manifest.aliases];
-      if (keywords.length === 0) continue;
-
-      const score = keywords.filter((kw) => lowerMsg.includes(kw.toLowerCase())).length;
-      const coverage = score / keywords.length;
-
-      // 保守策略：至少 2 个关键词命中，且覆盖率 >= 50%
-      if (score >= 2 && coverage >= 0.5 && (!bestMatch || score > bestMatch.score)) {
-        bestMatch = { manifest, score, coverage };
-      }
-    }
-
-    if (!bestMatch) return null;
-
-    // 命中后才触发懒加载全量内容
-    const storageKey = this.getManifestStorageKey(bestMatch.manifest);
-    const skill = this.skillManager.get(storageKey);
-    if (!skill) return null;
-
-    return {
-      skill,
-      message,
-      matchType: 'keyword',
-      confidence: bestMatch.coverage,
-    };
-  }
-}
-
-

package/src/skill/types.ts

@@ -1,67 +0,0 @@
-// ============================================================
-// Skill System 类型定义
-// ============================================================
-
-// ---- Skill 类型 ----
-
-export type SkillSource = 'system' | 'user' | 'remote';
-
-/**
- * Skill 轻量清单（仅 front matter，不含 content）
- * 用于大规模 Skill 库的索引、路由和 UI 展示
- */
-export interface SkillManifest {
-  /** 唯一标识 */
-  id: string;
-  /** 显示名称 */
-  name: string;
-  /** 功能描述（LLM 路由和 UI 展示用） */
-  description: string;
-  /** 关键词标签（用于关键词路由匹配） */
-  tags: string[];
-  /** 别名/同义词 */
-  aliases: string[];
-  /** 来源 */
-  source: SkillSource;
-  /** 版本号 */
-  version?: string;
-  /** 作者信息 */
-  author?: string;
-  /** 依赖的 MCP 工具名列表 */
-  requires?: string[];
-  /** 引用的其他 Skill ID 列表（懒加载，使用时自动加载） */
-  referencedSkills?: string[];
-  /** 文件路径（懒加载时从此路径读取 content） */
-  filePath?: string;
-  /** content 字符数（预估，用于 UI 展示和预算管理） */
-  contentSize?: number;
-  /** 扩展元数据 */
-  metadata?: Record<string, unknown>;
-}
-
-export interface Skill extends SkillManifest {
-  /** Skill 正文内容（懒加载时可能为空，需通过 SkillManager.get() 触发加载） */
-  content: string;
-}
-
-// ---- RouteResult / RouteStrategy ----
-
-export type MatchType = 'explicit' | 'keyword' | 'custom';
-
-export interface RouteResult {
-  /** 匹配到的 Skill（null 表示无匹配，使用裸 Agent） */
-  skill: Skill | null;
-  /** 路由后实际传给 Agent 的消息（显式调用时会剥离 /command 前缀） */
-  message: string;
-  /** 匹配方式 */
-  matchType: MatchType;
-  /** 匹配置信度（0-1） */
-  confidence: number;
-}
-
-/** 自定义路由策略接口 */
-export interface RouteStrategy {
-  name: string;
-  /** 执行路由，返回 RouteResult 或 null（交给下一策略） */
-  match(message: string, skills: Skill[]): Promise<RouteResult | null>;
-}