skyloom 1.4.0

package/src/web/tts.ts

@@ -0,0 +1,93 @@
+/**
+ * Text-to-Speech integration using Volcano Engine (Doubao) TTS API.
+ * Uses POST to https://openspeech.bytedance.com/api/v3/tts/unidirectional.
+ */
+
+const HTTP_ENDPOINT = 'https://openspeech.bytedance.com/api/v3/tts/unidirectional';
+
+export interface VoiceOption {
+  key: string;
+  name: string;
+  desc: string;
+  voiceType: string;
+}
+
+export const VOICE_CATALOG: VoiceOption[] = [
+  { key: 'xiaohe', name: '小河', desc: '温柔自然女声', voiceType: 'zh_female_xiaohe_uranus_bigtts' },
+  { key: 'qingxinnvsheng', name: '清新女声', desc: '清澈自然女声', voiceType: 'zh_female_qingxinnvsheng_uranus_bigtts' },
+  { key: 'cancan', name: '灿灿', desc: '活力甜美少女音', voiceType: 'zh_female_cancan_uranus_bigtts' },
+  { key: 'sajiaoxuemei', name: '撒娇雪梅', desc: '甜美撒娇少女音', voiceType: 'zh_female_sajiaoxuemei_uranus_bigtts' },
+  { key: 'meilinvyou', name: '魅力女游', desc: '温柔魅力女声', voiceType: 'zh_female_meilinvyou_uranus_bigtts' },
+  { key: 'xiaoshan', name: '小杉', desc: '温暖磁性男声', voiceType: 'zh_male_xiaoshan_uranus_bigtts' },
+];
+
+export interface TTSOptions {
+  text: string;
+  voice?: string;
+  speed?: number;
+  pitch?: number;
+  apiKey?: string;
+}
+
+export interface TTSResult {
+  success: boolean;
+  audioBase64?: string;
+  format?: string;
+  error?: string;
+}
+
+/**
+ * Convert text to speech using Volcano Engine TTS API.
+ */
+export async function textToSpeech(options: TTSOptions): Promise<TTSResult> {
+  const { text, voice = 'zh_female_xiaohe_uranus_bigtts', speed = 1.0, pitch = 1.0 } = options;
+
+  if (!text || !text.trim()) {
+    return { success: false, error: 'Text is required' };
+  }
+
+  const apiKey = options.apiKey || process.env.VOLC_ACCESS_TOKEN;
+  if (!apiKey) {
+    return { success: false, error: 'API key not configured. Set VOLC_ACCESS_TOKEN or pass apiKey.' };
+  }
+
+  const payload = {
+    app: { appid: process.env.VOLC_APP_ID || '' },
+    user: { uid: 'skyloom' },
+    request: {
+      reqid: Math.random().toString(36).slice(2, 14),
+      text,
+      text_type: 'plain',
+      operation: 'query',
+      frontend_type: 'unitTson',
+      voice: { voice_type: voice, speed_rate: speed, pitch_rate: pitch },
+      audio: { audio_type: 'mp3' },
+    },
+  };
+
+  try {
+    const response = await fetch(HTTP_ENDPOINT, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify(payload),
+    });
+
+    const data: any = await response.json();
+    if (data.code !== 3000) {
+      return { success: false, error: `API error: ${data.code} - ${data.message || 'unknown'}` };
+    }
+    return { success: true, audioBase64: data.data, format: 'mp3' };
+  } catch (e: any) {
+    return { success: false, error: `TTS request failed: ${e.message || e}` };
+  }
+}
+
+/**
+ * List available TTS voices.
+ */
+export function listVoices(): VoiceOption[] {
+  return [...VOICE_CATALOG];
+}

package/tests/bus.test.ts

@@ -0,0 +1,121 @@
+/**
+ * Tests for the event bus.
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { MessageBus, Event, EventType } from '../src/core/bus';
+
+describe('MessageBus', () => {
+  it('subscribe and publish broadcasts to subscribers', async () => {
+    const bus = new MessageBus();
+    const received: Event[] = [];
+
+    async function handler(event: Event) {
+      received.push(event);
+    }
+
+    bus.subscribe('test_agent', handler);
+    const event = new Event(EventType.SYSTEM_EVENT, 'system', null, { msg: 'hello' });
+    await bus.publish(event);
+
+    expect(received).toHaveLength(1);
+    expect(received[0].type).toBe(EventType.SYSTEM_EVENT);
+    expect(received[0].data).toEqual({ msg: 'hello' });
+  });
+
+  it('direct message goes to target agent only', async () => {
+    const bus = new MessageBus();
+    const received: Event[] = [];
+
+    async function handler(event: Event) {
+      received.push(event);
+    }
+
+    bus.subscribe('target_agent', handler);
+    const event = new Event(EventType.TASK_ASSIGNED, 'snow', 'target_agent', { task: 'test' });
+    await bus.publish(event);
+
+    expect(received).toHaveLength(1);
+  });
+
+  it('unsubscribe removes handler', async () => {
+    const bus = new MessageBus();
+    const received: Event[] = [];
+
+    async function handler(event: Event) {
+      received.push(event);
+    }
+
+    bus.subscribe('agent', handler);
+    bus.unsubscribe('agent');
+    await bus.publish(new Event(EventType.SYSTEM_EVENT, 'system'));
+    expect(received).toHaveLength(0);
+  });
+
+  it('state listener receives state change events', async () => {
+    const bus = new MessageBus();
+    const received: Event[] = [];
+
+    async function listener(event: Event) {
+      received.push(event);
+    }
+
+    bus.onStateChange(listener);
+    await bus.notifyStateChange(
+      new Event(EventType.STATE_CHANGE, 'fog', null, { old_state: 'idle', new_state: 'thinking' })
+    );
+
+    expect(received).toHaveLength(1);
+    expect(received[0].type).toBe(EventType.STATE_CHANGE);
+    expect(received[0].source).toBe('fog');
+  });
+
+  it('state listener ignores non-state events', async () => {
+    const bus = new MessageBus();
+    const received: Event[] = [];
+
+    async function listener(event: Event) {
+      received.push(event);
+    }
+
+    bus.onStateChange(listener);
+    await bus.notifyStateChange(new Event(EventType.TASK_ASSIGNED, 'snow'));
+    expect(received).toHaveLength(0);
+  });
+
+  it('history tracks published events', async () => {
+    const bus = new MessageBus();
+    for (let i = 0; i < 5; i++) {
+      await bus.publish(new Event(EventType.SYSTEM_EVENT, 'system'));
+    }
+    expect(bus.getHistory()).toHaveLength(5);
+    expect(bus.getHistory(undefined, undefined, 2)).toHaveLength(2);
+  });
+
+  it('broadcast skips source agent', async () => {
+    const bus = new MessageBus();
+    const called: string[] = [];
+
+    async function fogHandler(_event: Event) { called.push('fog'); }
+    async function rainHandler(_event: Event) { called.push('rain'); }
+
+    bus.subscribe('fog', fogHandler);
+    bus.subscribe('rain', rainHandler);
+    await bus.publish(new Event(EventType.SYSTEM_EVENT, 'fog'));
+
+    expect(called).not.toContain('fog');
+    expect(called).toContain('rain');
+  });
+
+  it('handler exception does not block other handlers', async () => {
+    const bus = new MessageBus();
+    const good: Event[] = [];
+
+    async function failing(_event: Event) { throw new Error('failed'); }
+    async function ok(event: Event) { good.push(event); }
+
+    bus.subscribe('rain', failing);
+    bus.subscribe('dew', ok);
+    await bus.publish(new Event(EventType.SYSTEM_EVENT, 'fog'));
+    expect(good).toHaveLength(1);
+  });
+});

package/tests/icons.test.ts

@@ -0,0 +1,45 @@
+/**
+ * Tests for agent icon system.
+ */
+import { describe, it, expect } from 'vitest';
+import { AGENT_COLORS, AGENT_EMOJI, iconText, svgPath } from '../src/core/icons';
+
+describe('AGENT_COLORS', () => {
+  it('has all 6 agents', () => {
+    expect(Object.keys(AGENT_COLORS).sort()).toEqual(['dew', 'fair', 'fog', 'frost', 'rain', 'snow']);
+  });
+
+  it('each agent has a non-empty color', () => {
+    for (const color of Object.values(AGENT_COLORS)) {
+      expect(color).toBeTruthy();
+    }
+  });
+});
+
+describe('AGENT_EMOJI', () => {
+  it('has all 6 agents', () => {
+    expect(Object.keys(AGENT_EMOJI).sort()).toEqual(['dew', 'fair', 'fog', 'frost', 'rain', 'snow']);
+  });
+
+  it('unique emoji per agent', () => {
+    const values = Object.values(AGENT_EMOJI);
+    expect(new Set(values).size).toBe(values.length);
+  });
+});
+
+describe('iconText', () => {
+  it('returns glyph for known agent', () => {
+    expect(iconText('fog')).toBe('≋');
+    expect(iconText('fair')).toBe('☼');
+  });
+
+  it('returns name as fallback for unknown agent', () => {
+    expect(iconText('unknown')).toBe('unknown');
+  });
+});
+
+describe('svgPath', () => {
+  it('returns a path ending with .svg', () => {
+    expect(svgPath('fog')).toContain('icons');
+  });
+});

package/tests/router.test.ts

@@ -0,0 +1,86 @@
+/**
+ * Tests for the complexity router.
+ */
+import { describe, it, expect } from 'vitest';
+import { classify, pickAgentForGoal } from '../src/core/router';
+
+describe('classify', () => {
+  it.each([
+    '你好',
+    'hi',
+    '在吗',
+    '谢谢',
+    '什么是 RAG?',
+    '为什么天空是蓝的？',
+    '1 + 1 = ?',
+    '解释一下闭包',
+  ])('returns "direct" for simple questions: %s', (goal) => {
+    expect(classify(goal)).toBe('direct');
+  });
+
+  it.each([
+    '帮我写一个二分查找函数',
+    '搜一下今天的天气',
+    '审查 src/foo.py 的安全问题',
+    '把这段中文翻译成英文：我喜欢猫',
+  ])('returns "single" for focused tasks: %s', (goal) => {
+    expect(classify(goal)).toBe('single');
+  });
+
+  it.each([
+    '先帮我分析这段代码，然后重构它，最后写测试',
+    '首先调研一下市场上有哪些方案，其次对比性能，最后给出推荐',
+    '1. 创建数据库迁移\n2. 写 API\n3. 加测试\n4. 部署',
+  ])('returns "orchestrate" for multi-step: %s', (goal) => {
+    expect(classify(goal)).toBe('orchestrate');
+  });
+
+  it('empty goal returns direct', () => {
+    expect(classify('')).toBe('direct');
+    expect(classify('   ')).toBe('direct');
+  });
+
+  it('inline enumerated list is orchestrate', () => {
+    expect(classify('1. 拉数据 2. 分析 3. 出图')).toBe('orchestrate');
+    expect(classify('先做 1. xxx 2. yyy 3. zzz 4. www')).toBe('orchestrate');
+  });
+
+  it('two inline items is not orchestrate', () => {
+    expect(classify('1. 你好 2. 谢谢')).not.toBe('orchestrate');
+  });
+});
+
+describe('pickAgentForGoal', () => {
+  const allAgents = new Set(['fog', 'rain', 'frost', 'snow', 'dew', 'fair']);
+
+  it('security keyword picks frost', () => {
+    expect(pickAgentForGoal('帮我做安全审查', allAgents)).toBe('frost');
+  });
+
+  it('research keyword picks fog', () => {
+    expect(pickAgentForGoal('搜一下最新的 React 文档', allAgents)).toBe('fog');
+  });
+
+  it('greeting picks fair', () => {
+    expect(pickAgentForGoal('你好啊', allAgents)).toBe('fair');
+  });
+
+  it('falls back to rain', () => {
+    expect(pickAgentForGoal('处理这个东西', allAgents)).toBe('rain');
+  });
+
+  it('binary search picks rain not fog', () => {
+    expect(pickAgentForGoal('帮我写一个二分查找', allAgents)).toBe('rain');
+    expect(pickAgentForGoal('实现一个排序函数', allAgents)).toBe('rain');
+  });
+
+  it('skips missing agents', () => {
+    const available = new Set(['rain', 'snow']);
+    const result = pickAgentForGoal('做安全审查', available);
+    expect(available.has(result)).toBe(true);
+  });
+
+  it('single agent available', () => {
+    expect(pickAgentForGoal('anything', new Set(['rain']))).toBe('rain');
+  });
+});

package/tests/schemas.test.ts

@@ -0,0 +1,51 @@
+/**
+ * Tests for structured output schema validation.
+ */
+import { describe, it, expect } from 'vitest';
+import { validateTaskPlan, TaskPlanSchema, parseSchema, SchemaValidationError } from '../src/core/schemas';
+
+describe('validateTaskPlan', () => {
+  it('parses valid JSON plan', () => {
+    const data = JSON.parse('{"goal": "build app", "steps": [{"id": "1", "description": "design", "agent": "fog"}]}');
+    const plan = validateTaskPlan(data);
+    expect(plan.goal).toBe('build app');
+    expect(plan.steps).toHaveLength(1);
+    expect(plan.steps[0].agent).toBe('fog');
+  });
+
+  it('passes through agent name', () => {
+    const data = JSON.parse('{"goal": "x", "steps": [{"id": "1", "description": "a", "agent": "unknown"}]}');
+    const plan = validateTaskPlan(data);
+    // Schema-level validation just passes through; agent fallback is in SnowAgent
+    expect(plan.steps[0].agent).toBe('unknown');
+  });
+
+  it('empty steps', () => {
+    const data = JSON.parse('{"goal": "x", "steps": []}');
+    const plan = validateTaskPlan(data);
+    expect(plan.steps).toHaveLength(0);
+  });
+
+  it('parses depends_on', () => {
+    const data = JSON.parse('{"goal": "x", "steps": [{"id": "1", "description": "a", "depends_on": ["0"]}]}');
+    const plan = validateTaskPlan(data);
+    expect(plan.steps[0].depends_on).toEqual(['0']);
+  });
+
+  it('default fields', () => {
+    const data = JSON.parse('{"goal": "x", "steps": [{"id": "1", "description": "a"}]}');
+    const plan = validateTaskPlan(data);
+    expect(plan.steps[0].agent).toBe('rain');
+    expect(plan.steps[0].depends_on).toEqual([]);
+  });
+});
+
+describe('SchemaValidationError', () => {
+  it('raises on empty', () => {
+    expect(() => parseSchema('', TaskPlanSchema)).toThrow(SchemaValidationError);
+  });
+
+  it('raises on garbage', () => {
+    expect(() => parseSchema('<html>garbage</html>', TaskPlanSchema)).toThrow(SchemaValidationError);
+  });
+});

package/tests/semantic.test.ts

@@ -0,0 +1,83 @@
+/**
+ * Tests for lightweight semantic retrieval.
+ */
+import { describe, it, expect } from 'vitest';
+import { SemanticScorer, getScorer } from '../src/core/semantic';
+
+describe('SemanticScorer', () => {
+  const scorer = new SemanticScorer();
+
+  it('identical strings score 1.0', () => {
+    expect(scorer.similarity('hello world', 'hello world')).toBe(1.0);
+  });
+
+  it('completely different strings score 0.0', () => {
+    expect(scorer.similarity('aaaaa', 'bbbbb')).toBe(0.0);
+  });
+
+  it('partial overlap scores between 0 and 1', () => {
+    const score = scorer.similarity('deploy to server', 'deployment script');
+    expect(score).toBeGreaterThan(0.0);
+    expect(score).toBeLessThan(1.0);
+  });
+
+  it('CJK similarity works', () => {
+    const score = scorer.similarity('部署', '部署命令');
+    expect(score).toBeGreaterThan(0.0);
+  });
+
+  it('empty strings return 0', () => {
+    expect(scorer.similarity('', 'hello')).toBe(0.0);
+    expect(scorer.similarity('hello', '')).toBe(0.0);
+    expect(scorer.similarity('', '')).toBe(0.0);
+  });
+
+  it('case insensitive', () => {
+    expect(scorer.similarity('Hello World', 'hello world')).toBe(1.0);
+  });
+
+  it('mixed language overlap', () => {
+    const score = scorer.similarity('pnpm install', 'pnpm 安装');
+    expect(score).toBeGreaterThan(0.0);
+  });
+
+  it('code identifiers match partially', () => {
+    const score = scorer.similarity('snake_case_var', 'snakeCaseVar');
+    expect(score).toBeGreaterThan(0.0);
+  });
+
+  it('rank returns ordered results', () => {
+    const candidates = [
+      { key: 'k1', value: 'deploy to production' },
+      { key: 'k2', value: 'install dependencies' },
+      { key: 'k3', value: 'rollback version' },
+    ];
+    const ranked = scorer.rank('deploy', candidates, 'value', 2);
+    expect(ranked.length).toBeLessThanOrEqual(2);
+    expect(ranked[0][1].key).toBe('k1');
+  });
+
+  it('rank filters below minScore', () => {
+    const candidates = [
+      { key: 'k1', value: 'completely unrelated text here' },
+    ];
+    const ranked = scorer.rank('zzzzz', candidates, 'value', 1, 0.5);
+    expect(ranked).toHaveLength(0);
+  });
+
+  it('rank uses key field boost', () => {
+    const candidates = [
+      { key: 'deploy_command', value: 'npm run build' },
+    ];
+    const ranked = scorer.rank('deploy', candidates, 'value', 1);
+    expect(ranked).toHaveLength(1);
+  });
+});
+
+describe('getScorer singleton', () => {
+  it('returns the same instance', () => {
+    const s1 = getScorer();
+    const s2 = getScorer();
+    expect(s1).toBe(s2);
+  });
+});

package/tests/setup.ts

@@ -0,0 +1,10 @@
+/**
+ * Test setup — global fixtures and mocks for Skyloom tests.
+ */
+import { vi, beforeEach } from 'vitest';
+import { MessageBus } from '../src/core/bus';
+
+// Clear tool state before each test
+beforeEach(() => {
+  // No-op — individual tests handle their own setup
+});

package/tests/skill.test.ts

@@ -0,0 +1,172 @@
+/**
+ * Tests for skill system.
+ */
+import { describe, it, expect } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+
+describe('Skill', () => {
+  it('creates a skill with model override', async () => {
+    const { Skill } = await import('../src/core/skill');
+    const skill = new Skill({
+      name: 'test_skill',
+      description: 'A test skill',
+      model: 'claude-opus-4-7',
+    });
+    expect(skill.model).toBe('claude-opus-4-7');
+    expect(skill.temperature).toBeNull();
+    expect(skill.maxTokens).toBeNull();
+  });
+
+  it('creates a skill with temperature override', async () => {
+    const { Skill } = await import('../src/core/skill');
+    const skill = new Skill({ name: 'test_skill', description: 'A test skill', temperature: 0.3 });
+    expect(skill.temperature).toBe(0.3);
+  });
+
+  it('creates a skill with max_tokens override', async () => {
+    const { Skill } = await import('../src/core/skill');
+    const skill = new Skill({ name: 'test_skill', description: 'A test skill', maxTokens: 32000 });
+    expect(skill.maxTokens).toBe(32000);
+  });
+
+  it('default has no overrides', async () => {
+    const { Skill } = await import('../src/core/skill');
+    const skill = new Skill({ name: 'test', description: 'test' });
+    expect(skill.model).toBeNull();
+    expect(skill.temperature).toBeNull();
+    expect(skill.maxTokens).toBeNull();
+  });
+});
+
+describe('Skill.fromMarkdown', () => {
+  it('loads skill with YAML frontmatter', async () => {
+    const { Skill } = await import('../src/core/skill');
+    const tmpDir = fs.mkdtempSync('skill-test-');
+    const mdPath = path.join(tmpDir, 'test.md');
+    fs.writeFileSync(mdPath, `---
+name: test_skill
+description: A test
+model: claude-sonnet-4-6
+temperature: 0.5
+max_tokens: 8192
+---
+
+## Test Skill
+This is a test skill.
+`, 'utf-8');
+
+    const skill = Skill.fromMarkdown(mdPath);
+    expect(skill).not.toBeNull();
+    if (skill) {
+      expect(skill.model).toBe('claude-sonnet-4-6');
+      expect(skill.temperature).toBe(0.5);
+      expect(skill.maxTokens).toBe(8192);
+      expect(skill.systemPrompt).toContain('This is a test skill');
+    }
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('supports string path', async () => {
+    const { Skill } = await import('../src/core/skill');
+    const tmpDir = fs.mkdtempSync('skill-test-');
+    const mdPath = path.join(tmpDir, 'x.md');
+    fs.writeFileSync(mdPath, '---\nname: x\ndescription: x\n---\n\nBody.', 'utf-8');
+    const s = Skill.fromMarkdown(mdPath);
+    expect(s).not.toBeNull();
+    if (s) {
+      expect(s.name).toBe('x');
+      expect(typeof s.sourcePath).toBe('string');
+    }
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('derives triggers from quoted descriptions', async () => {
+    const { Skill } = await import('../src/core/skill');
+    const tmpDir = fs.mkdtempSync('skill-test-');
+    const mdPath = path.join(tmpDir, 'pptx.md');
+    fs.writeFileSync(mdPath, `---
+name: pptx
+description: |-
+  Use this skill any time a .pptx file is involved.
+  Trigger whenever the user mentions "deck," "slides," or "presentation."
+  If a .pptx file needs to be opened, use it.
+---
+Body.`, 'utf-8');
+
+    const s = Skill.fromMarkdown(mdPath);
+    expect(s).not.toBeNull();
+    if (s) {
+      const triggersLower = s.triggers.map(t => t.toLowerCase());
+      expect(triggersLower).toContain('deck');
+      expect(triggersLower).toContain('slides');
+      expect(triggersLower).toContain('presentation');
+      expect(triggersLower).toContain('.pptx');
+    }
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('small body loaded in full', async () => {
+    const { Skill } = await import('../src/core/skill');
+    const tmpDir = fs.mkdtempSync('skill-test-');
+    const mdPath = path.join(tmpDir, 'small.md');
+    fs.writeFileSync(mdPath, '---\nname: small\ndescription: x\n---\n\n# Small Skill\n\nThis fits inline easily.', 'utf-8');
+    const s = Skill.fromMarkdown(mdPath);
+    expect(s).not.toBeNull();
+    if (s) {
+      expect(s.bodyTruncated).toBe(false);
+      expect(s.systemPrompt).toContain('This fits inline easily');
+    }
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('large body truncated to head', async () => {
+    const { Skill } = await import('../src/core/skill');
+    const tmpDir = fs.mkdtempSync('skill-test-');
+    const mdPath = path.join(tmpDir, 'big.md');
+
+    let body = '# Big Skill\n\n## Quick Reference\nFirst section content.\n\n';
+    body += '## Detailed Guide\n';
+    body += 'X'.repeat(5000);
+
+    fs.writeFileSync(mdPath, `---\nname: big\ndescription: x\n---\n\n${body}`, 'utf-8');
+    const s = Skill.fromMarkdown(mdPath);
+    expect(s).not.toBeNull();
+    if (s) {
+      expect(s.bodyTruncated).toBe(true);
+      expect(s.systemPrompt).toContain('Big Skill');
+      expect(s.systemPrompt).toContain('Quick Reference');
+      expect(s.systemPrompt).not.toContain('Detailed Guide');
+    }
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+});
+
+describe('SkillRegistry', () => {
+  it('registers and retrieves skills', async () => {
+    const { Skill, SkillRegistry } = await import('../src/core/skill');
+    const reg = new SkillRegistry();
+    const skill = new Skill({ name: 'test', description: 'Test' });
+    reg.register(skill);
+    expect(reg.get('test')).toBe(skill);
+    expect(reg.get('missing')).toBeUndefined();
+  });
+
+  it('lists names', async () => {
+    const { Skill, SkillRegistry } = await import('../src/core/skill');
+    const reg = new SkillRegistry();
+    reg.register(new Skill({ name: 'a', description: 'A' }));
+    reg.register(new Skill({ name: 'b', description: 'B' }));
+    expect(reg.listNames()).toEqual(['a', 'b']);
+  });
+
+  it('merges registries', async () => {
+    const { Skill, SkillRegistry } = await import('../src/core/skill');
+    const r1 = new SkillRegistry();
+    r1.register(new Skill({ name: 'a', description: 'A' }));
+    const r2 = new SkillRegistry();
+    r2.register(new Skill({ name: 'b', description: 'B' }));
+    r1.merge(r2);
+    expect(r1.get('b')).toBeDefined();
+  });
+});