opc-agent 4.1.2 → 4.1.4

package/tests/telemetry.test.ts

@@ -1,186 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import {
-  Tracer,
-  ConsoleExporter,
-  FileExporter,
-  generateTraceId,
-  generateSpanId,
-} from '../src/telemetry';
-import { BaseAgent } from '../src/core/agent';
-
-describe('Telemetry', () => {
-  let tracer: Tracer;
-
-  beforeEach(() => {
-    tracer = new Tracer({ maxSpans: 100 });
-  });
-
-  it('startSpan creates span with correct fields', () => {
-    const span = tracer.startSpan('test-op', {
-      attributes: { foo: 'bar' },
-      kind: 'server',
-    });
-    expect(span.name).toBe('test-op');
-    expect(span.kind).toBe('server');
-    expect(span.status).toBe('unset');
-    expect(span.traceId).toHaveLength(32);
-    expect(span.spanId).toHaveLength(16);
-    expect(span.attributes.foo).toBe('bar');
-    expect(span.events).toEqual([]);
-    expect(span.startTime).toBeGreaterThan(0);
-    expect(span.endTime).toBeUndefined();
-  });
-
-  it('endSpan sets endTime and status', () => {
-    const span = tracer.startSpan('op');
-    tracer.endSpan(span, 'ok');
-    expect(span.endTime).toBeGreaterThanOrEqual(span.startTime);
-    expect(span.status).toBe('ok');
-  });
-
-  it('endSpan defaults to ok status', () => {
-    const span = tracer.startSpan('op');
-    tracer.endSpan(span);
-    expect(span.status).toBe('ok');
-  });
-
-  it('addEvent adds to span events', () => {
-    const span = tracer.startSpan('op');
-    tracer.addEvent(span, 'checkpoint', { key: 'val' });
-    expect(span.events).toHaveLength(1);
-    expect(span.events[0].name).toBe('checkpoint');
-    expect(span.events[0].attributes?.key).toBe('val');
-    expect(span.events[0].timestamp).toBeGreaterThan(0);
-  });
-
-  it('getSpans with filters', () => {
-    const s1 = tracer.startSpan('alpha', { attributes: {} });
-    const s2 = tracer.startSpan('beta', { attributes: {} });
-    tracer.endSpan(s1);
-    tracer.endSpan(s2);
-
-    expect(tracer.getSpans({ name: 'alpha' })).toHaveLength(1);
-    expect(tracer.getSpans({ traceId: s1.traceId })).toHaveLength(1);
-    expect(tracer.getSpans({ limit: 1 })).toHaveLength(1);
-  });
-
-  it('getTrace returns all spans for traceId', () => {
-    const parent = tracer.startSpan('root');
-    const child = tracer.startSpan('child', { parent });
-    tracer.endSpan(child);
-    tracer.endSpan(parent);
-
-    const trace = tracer.getTrace(parent.traceId);
-    expect(trace).toHaveLength(2);
-    expect(trace[0].spanId).toBe(parent.spanId);
-    expect(trace[1].parentSpanId).toBe(parent.spanId);
-  });
-
-  it('getStats returns correct stats', () => {
-    const s1 = tracer.startSpan('op1');
-    tracer.endSpan(s1, 'ok');
-    const s2 = tracer.startSpan('op2');
-    tracer.endSpan(s2, 'error');
-
-    const stats = tracer.getStats();
-    expect(stats.totalSpans).toBe(2);
-    expect(stats.totalTraces).toBe(2);
-    expect(stats.errorRate).toBe(0.5);
-    expect(stats.spansByName).toEqual({ op1: 1, op2: 1 });
-    expect(stats.p50Latency).toBeGreaterThanOrEqual(0);
-    expect(stats.p95Latency).toBeGreaterThanOrEqual(0);
-    expect(stats.p99Latency).toBeGreaterThanOrEqual(0);
-  });
-
-  it('increment/gauge/histogram add metrics', () => {
-    tracer.increment('requests', 1, { method: 'GET' });
-    tracer.gauge('connections', 5);
-    tracer.histogram('latency', 42.5, { route: '/api' });
-
-    const metrics = tracer.getMetrics();
-    expect(metrics).toHaveLength(3);
-    expect(metrics[0]).toMatchObject({ name: 'requests', type: 'counter', value: 1 });
-    expect(metrics[1]).toMatchObject({ name: 'connections', type: 'gauge', value: 5 });
-    expect(metrics[2]).toMatchObject({ name: 'latency', type: 'histogram', value: 42.5 });
-  });
-
-  it('maxSpans eviction', () => {
-    const t = new Tracer({ maxSpans: 5 });
-    for (let i = 0; i < 10; i++) {
-      t.startSpan(`span-${i}`);
-    }
-    const spans = t.getSpans();
-    expect(spans.length).toBe(5);
-    // oldest evicted, newest 5 kept (span-5 through span-9)
-    const names = spans.map(s => s.name).sort();
-    expect(names).toEqual(['span-5', 'span-6', 'span-7', 'span-8', 'span-9']);
-  });
-
-  it('ConsoleExporter exports to console', async () => {
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const exporter = new ConsoleExporter();
-    const span = tracer.startSpan('test');
-    tracer.endSpan(span);
-    await exporter.export([span]);
-    expect(consoleSpy).toHaveBeenCalledTimes(1);
-    expect(consoleSpy.mock.calls[0][0]).toContain('[TRACE]');
-    consoleSpy.mockRestore();
-  });
-
-  it('FileExporter exports to file', async () => {
-    const fs = require('fs');
-    const tmpFile = require('path').join(require('os').tmpdir(), `opc-test-${Date.now()}.ndjson`);
-    const exporter = new FileExporter(tmpFile);
-    const span = tracer.startSpan('file-test');
-    tracer.endSpan(span);
-    await exporter.export([span]);
-    const content = fs.readFileSync(tmpFile, 'utf-8');
-    expect(content).toContain('file-test');
-    fs.unlinkSync(tmpFile);
-  });
-
-  it('generateTraceId returns 32 hex chars', () => {
-    const id = generateTraceId();
-    expect(id).toHaveLength(32);
-    expect(/^[0-9a-f]{32}$/.test(id)).toBe(true);
-  });
-
-  it('generateSpanId returns 16 hex chars', () => {
-    const id = generateSpanId();
-    expect(id).toHaveLength(16);
-    expect(/^[0-9a-f]{16}$/.test(id)).toBe(true);
-  });
-
-  it('exportOTLP produces OTel-compatible format', () => {
-    const span = tracer.startSpan('otlp-test', { attributes: { key: 'val' } });
-    tracer.endSpan(span);
-    const otlp = tracer.exportOTLP() as any;
-    expect(otlp.resourceSpans).toHaveLength(1);
-    expect(otlp.resourceSpans[0].scopeSpans[0].spans).toHaveLength(1);
-    const s = otlp.resourceSpans[0].scopeSpans[0].spans[0];
-    expect(s.name).toBe('otlp-test');
-    expect(s.traceId).toBe(span.traceId);
-  });
-
-  it('clear removes all spans and metrics', () => {
-    tracer.startSpan('x');
-    tracer.increment('m');
-    tracer.clear();
-    expect(tracer.getSpans()).toHaveLength(0);
-    expect(tracer.getMetrics()).toHaveLength(0);
-  });
-
-  it('agent integration: tracer on BaseAgent', () => {
-    const t = new Tracer();
-    const agent = new BaseAgent({ name: 'test', tracer: t });
-    expect(agent.getTracer()).toBe(t);
-  });
-
-  it('agent integration: setTracer works', () => {
-    const agent = new BaseAgent({ name: 'test' });
-    expect(agent.getTracer()).toBeUndefined();
-    const t = new Tracer();
-    agent.setTracer(t);
-    expect(agent.getTracer()).toBe(t);
-  });
-});

package/tests/templates.test.ts

@@ -1,77 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { createLegalAssistantConfig, ContractReviewSkill, ComplianceCheckSkill } from '../src/templates/legal-assistant';
-import { createFinancialAdvisorConfig, BudgetAnalysisSkill, FinancialPlanningSkill } from '../src/templates/financial-advisor';
-import { createExecutiveAssistantConfig, CalendarSkill, EmailDraftSkill, MeetingPrepSkill } from '../src/templates/executive-assistant';
-import type { AgentContext, Message, MemoryStore } from '../src/core/types';
-
-const mockMemory: MemoryStore = {
-  get: async () => null, set: async () => {}, getConversation: async () => [],
-  addMessage: async () => {}, clear: async () => {},
-};
-const ctx: AgentContext = { agentName: 'test', sessionId: 's1', messages: [], memory: mockMemory, metadata: {} };
-const msg = (content: string): Message => ({ id: '1', role: 'user', content, timestamp: Date.now() });
-
-describe('Legal Assistant Template', () => {
-  it('should create valid config', () => {
-    const config = createLegalAssistantConfig();
-    expect(config.metadata.name).toBe('legal-assistant');
-    expect(config.spec.skills).toHaveLength(2);
-  });
-
-  it('ContractReviewSkill matches contract terms', async () => {
-    const skill = new ContractReviewSkill();
-    const r = await skill.execute(ctx, msg('What is force majeure?'));
-    expect(r.handled).toBe(true);
-  });
-
-  it('ComplianceCheckSkill matches GDPR', async () => {
-    const skill = new ComplianceCheckSkill();
-    const r = await skill.execute(ctx, msg('GDPR requirements'));
-    expect(r.handled).toBe(true);
-  });
-});
-
-describe('Financial Advisor Template', () => {
-  it('should create valid config', () => {
-    const config = createFinancialAdvisorConfig();
-    expect(config.metadata.name).toBe('financial-advisor');
-  });
-
-  it('BudgetAnalysisSkill matches budget queries', async () => {
-    const skill = new BudgetAnalysisSkill();
-    const r = await skill.execute(ctx, msg('Help with my budget'));
-    expect(r.handled).toBe(true);
-  });
-
-  it('FinancialPlanningSkill matches investment queries', async () => {
-    const skill = new FinancialPlanningSkill();
-    const r = await skill.execute(ctx, msg('How to invest'));
-    expect(r.handled).toBe(true);
-  });
-});
-
-describe('Executive Assistant Template', () => {
-  it('should create valid config', () => {
-    const config = createExecutiveAssistantConfig();
-    expect(config.metadata.name).toBe('executive-assistant');
-    expect(config.spec.skills).toHaveLength(3);
-  });
-
-  it('CalendarSkill matches scheduling', async () => {
-    const skill = new CalendarSkill();
-    const r = await skill.execute(ctx, msg('Schedule a meeting'));
-    expect(r.handled).toBe(true);
-  });
-
-  it('EmailDraftSkill matches email queries', async () => {
-    const skill = new EmailDraftSkill();
-    const r = await skill.execute(ctx, msg('Draft an email'));
-    expect(r.handled).toBe(true);
-  });
-
-  it('MeetingPrepSkill matches prep queries', async () => {
-    const skill = new MeetingPrepSkill();
-    const r = await skill.execute(ctx, msg('Prepare the agenda'));
-    expect(r.handled).toBe(true);
-  });
-});

package/tests/tools/builtin-extended.test.ts

@@ -1,138 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { getBuiltinTools, getBuiltinToolsByName, fileTool, datetimeTool, shellTool, webTool } from '../../src/tools/builtin';
-
-describe('getBuiltinTools', () => {
-  it('returns 4 tools', () => {
-    const tools = getBuiltinTools();
-    expect(tools).toHaveLength(31);
-  });
-
-  it('returns copies (not same array)', () => {
-    const a = getBuiltinTools();
-    const b = getBuiltinTools();
-    expect(a).not.toBe(b);
-  });
-
-  it('contains file_operations tool', () => {
-    const tools = getBuiltinTools();
-    expect(tools.some(t => t.name === 'file_operations')).toBe(true);
-  });
-
-  it('contains datetime tool', () => {
-    const tools = getBuiltinTools();
-    expect(tools.some(t => t.name === 'datetime')).toBe(true);
-  });
-});
-
-describe('getBuiltinToolsByName', () => {
-  it('returns all when no names given', () => {
-    expect(getBuiltinToolsByName()).toHaveLength(31);
-    expect(getBuiltinToolsByName([])).toHaveLength(31);
-  });
-
-  it('filters by name correctly', () => {
-    const tools = getBuiltinToolsByName(['datetime']);
-    expect(tools).toHaveLength(1);
-    expect(tools[0].name).toBe('datetime');
-  });
-
-  it('returns empty for unknown names', () => {
-    const tools = getBuiltinToolsByName(['nonexistent']);
-    expect(tools).toHaveLength(0);
-  });
-
-  it('returns multiple matching tools', () => {
-    const tools = getBuiltinToolsByName(['datetime', 'file_operations']);
-    expect(tools).toHaveLength(2);
-  });
-});
-
-describe('fileTool', () => {
-  let tmpDir: string;
-  let origCwd: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'builtin-test-'));
-    origCwd = process.cwd();
-    process.chdir(tmpDir);
-  });
-
-  afterEach(() => {
-    process.chdir(origCwd);
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('has name file_operations', () => {
-    expect(fileTool.name).toBe('file_operations');
-  });
-
-  it('read existing file', async () => {
-    fs.writeFileSync(path.join(tmpDir, 'test.txt'), 'hello world');
-    const result = await fileTool.execute({ action: 'read', path: 'test.txt' });
-    expect(result.content).toContain('hello world');
-    expect(result.isError).toBeFalsy();
-  });
-
-  it('read non-existent returns error', async () => {
-    const result = await fileTool.execute({ action: 'read', path: 'nonexistent.txt' });
-    expect(result.isError).toBe(true);
-  });
-
-  it('write creates file', async () => {
-    const result = await fileTool.execute({ action: 'write', path: 'out.txt', content: 'data' });
-    expect(result.isError).toBeFalsy();
-    expect(fs.readFileSync(path.join(tmpDir, 'out.txt'), 'utf-8')).toBe('data');
-  });
-
-  it('list directory', async () => {
-    fs.writeFileSync(path.join(tmpDir, 'a.txt'), 'a');
-    fs.writeFileSync(path.join(tmpDir, 'b.txt'), 'b');
-    const result = await fileTool.execute({ action: 'list', path: '.' });
-    expect(result.content).toContain('a.txt');
-    expect(result.content).toContain('b.txt');
-  });
-
-  it('exists returns true for existing file', async () => {
-    fs.writeFileSync(path.join(tmpDir, 'exists.txt'), 'yes');
-    const result = await fileTool.execute({ action: 'exists', path: 'exists.txt' });
-    expect(result.content).toContain('true');
-  });
-
-  it('exists returns false for missing file', async () => {
-    const result = await fileTool.execute({ action: 'exists', path: 'nope.txt' });
-    expect(result.content).toContain('false');
-  });
-
-  it('path escape blocked (../)', async () => {
-    const result = await fileTool.execute({ action: 'read', path: '../../../etc/passwd' });
-    expect(result.isError).toBe(true);
-  });
-});
-
-describe('datetimeTool', () => {
-  it('has name datetime', () => {
-    expect(datetimeTool.name).toBe('datetime');
-  });
-
-  it('returns valid ISO string', async () => {
-    const result = await datetimeTool.execute({});
-    expect(result.isError).toBeFalsy();
-    // Should contain a date-like string
-    expect(result.content).toMatch(/\d{4}/);
-  });
-});
-
-describe('shellTool', () => {
-  it('has name shell_exec', () => {
-    expect(shellTool.name).toBe('shell_exec');
-  });
-});
-
-describe('webTool', () => {
-  it('has name web_fetch', () => {
-    expect(webTool.name).toBe('web_fetch');
-  });
-});

package/tests/user-profiler.test.ts

@@ -1,169 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { UserProfiler } from '../src/memory/user-profiler';
-import type { Message } from '../src/core/types';
-
-function makeMsg(role: 'user' | 'assistant', content: string): Message {
-  return { id: `msg-${Math.random()}`, role, content, timestamp: Date.now() };
-}
-
-describe('UserProfiler', () => {
-  describe('observe', () => {
-    it('should only process user messages', async () => {
-      const p = new UserProfiler();
-      await p.observe(makeMsg('assistant', 'hello'));
-      const profile = await p.getProfile();
-      expect(profile.communication_style).toBe('unknown'); // no observations
-    });
-
-    it('should detect Chinese language preference', async () => {
-      const p = new UserProfiler();
-      await p.observe(makeMsg('user', '你好，请帮我分析一下这个架构'));
-      const profile = await p.getProfile();
-      expect(profile.preferences.language).toBe('chinese');
-    });
-
-    it('should detect English language preference', async () => {
-      const p = new UserProfiler();
-      await p.observe(makeMsg('user', 'Please help me review this code'));
-      const profile = await p.getProfile();
-      expect(profile.preferences.language).toBe('english');
-    });
-
-    it('should detect mixed language', async () => {
-      const p = new UserProfiler();
-      await p.observe(makeMsg('user', '帮我看看这个 TypeScript 的 architecture 设计'));
-      const profile = await p.getProfile();
-      expect(profile.preferences.language).toBe('mixed');
-    });
-
-    it('should detect brief communication style', async () => {
-      const p = new UserProfiler();
-      await p.observe(makeMsg('user', 'fix the bug'));
-      await p.observe(makeMsg('user', 'deploy it'));
-      await p.observe(makeMsg('user', 'check logs'));
-      const profile = await p.getProfile();
-      expect(profile.communication_style).toBe('brief');
-    });
-
-    it('should detect casual style', async () => {
-      const p = new UserProfiler();
-      // Use long-enough text so "brief" doesn't dominate, and add multiple casual signals
-      await p.observe(makeMsg('user', 'lol this is so broken haha 😂 let me check what is going on here because this is really funny!! 666 amazing stuff right there'));
-      await p.observe(makeMsg('user', 'haha omg 😂😂 this is hilarious, the whole thing just crashed lol 666 no way this works'));
-      const profile = await p.getProfile();
-      expect(profile.communication_style).toBe('casual');
-    });
-
-    it('should extract tech keywords', async () => {
-      const p = new UserProfiler();
-      await p.observe(makeMsg('user', 'I need to deploy the Docker container with Kubernetes'));
-      const profile = await p.getProfile();
-      expect(profile.expertise_areas).toContain('Docker');
-      expect(profile.expertise_areas).toContain('Kubernetes');
-    });
-
-    it('should classify how-to requests', async () => {
-      const p = new UserProfiler();
-      await p.observe(makeMsg('user', 'how to deploy a React app?'));
-      const profile = await p.getProfile();
-      expect(profile.common_requests).toContain('how-to');
-    });
-
-    it('should classify debugging requests', async () => {
-      const p = new UserProfiler();
-      await p.observe(makeMsg('user', 'I got an error when building the project'));
-      const profile = await p.getProfile();
-      expect(profile.common_requests).toContain('debugging');
-    });
-
-    it('should learn to brain every 20 observations', async () => {
-      const brain = { learn: vi.fn().mockResolvedValue(undefined) };
-      const p = new UserProfiler();
-      for (let i = 0; i < 20; i++) {
-        await p.observe(makeMsg('user', `message ${i}`), brain);
-      }
-      expect(brain.learn).toHaveBeenCalledTimes(1);
-      expect(brain.learn).toHaveBeenCalledWith(
-        expect.any(String),
-        { insight_type: 'user_profile' }
-      );
-    });
-
-    it('should handle brain.learn failure gracefully', async () => {
-      const brain = { learn: vi.fn().mockRejectedValue(new Error('fail')) };
-      const p = new UserProfiler();
-      for (let i = 0; i < 20; i++) {
-        await p.observe(makeMsg('user', `message ${i}`), brain);
-      }
-      // Should not throw
-      const profile = await p.getProfile();
-      expect(profile).toBeDefined();
-    });
-  });
-
-  describe('getProfile', () => {
-    it('should return empty profile with no observations', async () => {
-      const p = new UserProfiler();
-      const profile = await p.getProfile();
-      expect(profile.communication_style).toBe('unknown');
-      expect(profile.expertise_areas).toEqual([]);
-    });
-
-    it('should fall back to brain recall when no local data', async () => {
-      const p = new UserProfiler();
-      const stored = JSON.stringify({ preferences: { language: 'chinese' }, communication_style: 'brief', expertise_areas: ['React'], common_requests: [], last_updated: 1 });
-      const brain = { recall: vi.fn().mockResolvedValue([stored]) };
-      const profile = await p.getProfile(brain);
-      expect(profile.preferences.language).toBe('chinese');
-    });
-
-    it('should handle brain recall failure', async () => {
-      const p = new UserProfiler();
-      const brain = { recall: vi.fn().mockRejectedValue(new Error('fail')) };
-      const profile = await p.getProfile(brain);
-      expect(profile.communication_style).toBe('unknown');
-    });
-  });
-
-  describe('enhance', () => {
-    it('should append language hint', () => {
-      const p = new UserProfiler();
-      const profile = { preferences: { language: 'chinese' }, communication_style: 'unknown', expertise_areas: [], common_requests: [], last_updated: 0 };
-      const result = p.enhance('You are a helpful assistant.', profile);
-      expect(result).toContain('Chinese');
-    });
-
-    it('should append style hint', () => {
-      const p = new UserProfiler();
-      const profile = { preferences: {}, communication_style: 'brief', expertise_areas: [], common_requests: [], last_updated: 0 };
-      const result = p.enhance('Base prompt', profile);
-      expect(result).toContain('brief');
-    });
-
-    it('should append expertise areas', () => {
-      const p = new UserProfiler();
-      const profile = { preferences: {}, communication_style: 'unknown', expertise_areas: ['React', 'TypeScript'], common_requests: [], last_updated: 0 };
-      const result = p.enhance('Base prompt', profile);
-      expect(result).toContain('React');
-      expect(result).toContain('TypeScript');
-    });
-
-    it('should not modify prompt for empty profile', () => {
-      const p = new UserProfiler();
-      const profile = { preferences: {}, communication_style: 'unknown', expertise_areas: [], common_requests: [], last_updated: 0 };
-      const result = p.enhance('Base prompt', profile);
-      expect(result).toBe('Base prompt');
-    });
-
-    it('should include all hints when profile is rich', () => {
-      const p = new UserProfiler();
-      const profile = { preferences: { language: 'english' }, communication_style: 'detailed', expertise_areas: ['Docker'], common_requests: ['how-to'], last_updated: Date.now() };
-      const result = p.enhance('Base', profile);
-      expect(result).toContain('[User Profile]');
-      expect(result).toContain('English');
-      expect(result).toContain('detailed');
-      expect(result).toContain('Docker');
-      expect(result).toContain('how-to');
-    });
-  });
-});

package/tests/v070.test.ts

@@ -1,76 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { createAuthMiddleware, getActiveSessions } from '../src/core/auth';
-import { HttpSkill } from '../src/skills/http';
-import { WebhookTriggerSkill } from '../src/skills/webhook-trigger';
-import { SchedulerSkill } from '../src/skills/scheduler';
-import type { AgentContext, Message } from '../src/core/types';
-
-const mockContext: AgentContext = {
-  agentName: 'test',
-  sessionId: 'test-session',
-  messages: [],
-  memory: { get: async () => null, set: async () => {}, getConversation: async () => [], addMessage: async () => {}, clear: async () => {} },
-  metadata: {},
-};
-
-function msg(content: string): Message {
-  return { id: '1', role: 'user', content, timestamp: Date.now() };
-}
-
-describe('Auth', () => {
-  it('should create middleware', () => {
-    const mw = createAuthMiddleware({ apiKeys: ['test-key'] });
-    expect(typeof mw).toBe('function');
-  });
-
-  it('should track sessions', () => {
-    const sessions = getActiveSessions();
-    expect(Array.isArray(sessions)).toBe(true);
-  });
-});
-
-describe('HttpSkill', () => {
-  it('should not match non-http messages', async () => {
-    const skill = new HttpSkill();
-    const result = await skill.execute(mockContext, msg('hello'));
-    expect(result.handled).toBe(false);
-  });
-});
-
-describe('WebhookTriggerSkill', () => {
-  it('should report unknown webhook', async () => {
-    const skill = new WebhookTriggerSkill();
-    const result = await skill.execute(mockContext, msg('webhook test'));
-    expect(result.handled).toBe(true);
-    expect(result.response).toContain('Unknown webhook');
-  });
-
-  it('should register targets', () => {
-    const skill = new WebhookTriggerSkill();
-    skill.registerTarget({ name: 'slack', url: 'https://hooks.slack.com/test' });
-    expect(skill).toBeDefined();
-  });
-});
-
-describe('SchedulerSkill', () => {
-  it('should list empty tasks', async () => {
-    const skill = new SchedulerSkill();
-    const result = await skill.execute(mockContext, msg('schedule list'));
-    expect(result.handled).toBe(true);
-    expect(result.response).toContain('No scheduled tasks');
-  });
-
-  it('should add a task', async () => {
-    const skill = new SchedulerSkill();
-    const result = await skill.execute(mockContext, msg('schedule add backup "every 5m" run backup'));
-    expect(result.handled).toBe(true);
-    expect(result.response).toContain('Task scheduled');
-    skill.destroy();
-  });
-
-  it('should not match unrelated messages', async () => {
-    const skill = new SchedulerSkill();
-    const result = await skill.execute(mockContext, msg('hello'));
-    expect(result.handled).toBe(false);
-  });
-});