@auxiora/ambient 1.0.0

package/tests/orchestrator.test.ts

@@ -0,0 +1,343 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { NotificationOrchestrator } from '../src/orchestrator.js';
+import type { OrchestratorNotification, DeliveryChannelFn } from '../src/orchestrator.js';
+import type { TriggerEvent } from '@auxiora/connectors';
+import { NotificationHub, DoNotDisturbManager } from '@auxiora/notification-hub';
+
+describe('NotificationOrchestrator', () => {
+  let hub: NotificationHub;
+  let dnd: DoNotDisturbManager;
+  let delivered: OrchestratorNotification[];
+  let deliveryChannel: DeliveryChannelFn;
+  let orchestrator: NotificationOrchestrator;
+
+  beforeEach(() => {
+    hub = new NotificationHub();
+    dnd = new DoNotDisturbManager();
+    delivered = [];
+    deliveryChannel = (n) => delivered.push(n);
+    orchestrator = new NotificationOrchestrator(hub, dnd, deliveryChannel);
+  });
+
+  describe('processTriggerEvents', () => {
+    it('should map new-email with urgency keyword to urgent priority', () => {
+      const event: TriggerEvent = {
+        triggerId: 'new-email',
+        connectorId: 'email-connector',
+        data: { subject: 'URGENT: Server down', from: 'ops@example.com' },
+        timestamp: Date.now(),
+      };
+
+      const results = orchestrator.processTriggerEvents([event]);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].priority).toBe('urgent');
+      expect(results[0].message).toContain('ops@example.com');
+      expect(results[0].message).toContain('URGENT: Server down');
+    });
+
+    it('should detect various urgency keywords case-insensitively', () => {
+      const keywords = ['urgent', 'ASAP', 'Important', 'Action Required', 'DEADLINE'];
+
+      for (const keyword of keywords) {
+        const hub2 = new NotificationHub();
+        const delivered2: OrchestratorNotification[] = [];
+        const orch = new NotificationOrchestrator(hub2, dnd, (n) => delivered2.push(n));
+
+        const event: TriggerEvent = {
+          triggerId: 'new-email',
+          connectorId: 'email-connector',
+          data: { subject: `Re: ${keyword} meeting notes`, from: 'test@test.com' },
+          timestamp: Date.now(),
+        };
+
+        const results = orch.processTriggerEvents([event]);
+        expect(results[0].priority).toBe('urgent');
+      }
+    });
+
+    it('should map new-email without urgency keywords to important priority', () => {
+      const event: TriggerEvent = {
+        triggerId: 'new-email',
+        connectorId: 'email-connector',
+        data: { subject: 'Weekly newsletter', from: 'news@example.com' },
+        timestamp: Date.now(),
+      };
+
+      const results = orchestrator.processTriggerEvents([event]);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].priority).toBe('important');
+    });
+
+    it('should map event-starting-soon to important priority', () => {
+      const event: TriggerEvent = {
+        triggerId: 'event-starting-soon',
+        connectorId: 'calendar-connector',
+        data: { title: 'Team standup' },
+        timestamp: Date.now(),
+      };
+
+      const results = orchestrator.processTriggerEvents([event]);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].priority).toBe('important');
+      expect(results[0].message).toContain('Team standup');
+      expect(results[0].source).toBe('calendar');
+    });
+
+    it('should map file-shared to low priority', () => {
+      const event: TriggerEvent = {
+        triggerId: 'file-shared',
+        connectorId: 'drive-connector',
+        data: { fileName: 'report.pdf', sharedBy: 'Alice' },
+        timestamp: Date.now(),
+      };
+
+      const results = orchestrator.processTriggerEvents([event]);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].priority).toBe('low');
+      expect(results[0].message).toContain('Alice');
+      expect(results[0].message).toContain('report.pdf');
+    });
+
+    it('should map unknown trigger events to low priority', () => {
+      const event: TriggerEvent = {
+        triggerId: 'some-unknown-trigger',
+        connectorId: 'custom-connector',
+        data: {},
+        timestamp: Date.now(),
+      };
+
+      const results = orchestrator.processTriggerEvents([event]);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].priority).toBe('low');
+      expect(results[0].message).toContain('custom-connector');
+    });
+
+    it('should process multiple events at once', () => {
+      const events: TriggerEvent[] = [
+        {
+          triggerId: 'new-email',
+          connectorId: 'email',
+          data: { subject: 'Hello', from: 'a@b.com' },
+          timestamp: Date.now(),
+        },
+        {
+          triggerId: 'file-shared',
+          connectorId: 'drive',
+          data: { fileName: 'doc.txt', sharedBy: 'Bob' },
+          timestamp: Date.now(),
+        },
+      ];
+
+      const results = orchestrator.processTriggerEvents(events);
+      expect(results).toHaveLength(2);
+    });
+
+    it('should send notifications to the hub', () => {
+      const event: TriggerEvent = {
+        triggerId: 'new-email',
+        connectorId: 'email',
+        data: { subject: 'Test', from: 'x@y.com' },
+        timestamp: Date.now(),
+      };
+
+      orchestrator.processTriggerEvents([event]);
+
+      const hubNotifications = hub.getAll();
+      expect(hubNotifications).toHaveLength(1);
+      expect(hubNotifications[0].source).toBe('email');
+    });
+  });
+
+  describe('DND filtering', () => {
+    it('should deliver notifications when DND is inactive', () => {
+      const event: TriggerEvent = {
+        triggerId: 'new-email',
+        connectorId: 'email',
+        data: { subject: 'Hello', from: 'a@b.com' },
+        timestamp: Date.now(),
+      };
+
+      orchestrator.processTriggerEvents([event]);
+
+      expect(delivered).toHaveLength(1);
+      expect(delivered[0].delivered).toBe(true);
+    });
+
+    it('should queue non-urgent notifications when DND is active', () => {
+      dnd.setManual(60_000);
+
+      const event: TriggerEvent = {
+        triggerId: 'new-email',
+        connectorId: 'email',
+        data: { subject: 'Hello', from: 'a@b.com' },
+        timestamp: Date.now(),
+      };
+
+      orchestrator.processTriggerEvents([event]);
+
+      expect(delivered).toHaveLength(0);
+      expect(orchestrator.getPending()).toHaveLength(1);
+      expect(orchestrator.getPending()[0].delivered).toBe(false);
+    });
+
+    it('should allow urgent notifications through DND', () => {
+      dnd.setManual(60_000);
+
+      const event: TriggerEvent = {
+        triggerId: 'new-email',
+        connectorId: 'email',
+        data: { subject: 'URGENT: Production is down', from: 'ops@co.com' },
+        timestamp: Date.now(),
+      };
+
+      orchestrator.processTriggerEvents([event]);
+
+      expect(delivered).toHaveLength(1);
+      expect(delivered[0].priority).toBe('urgent');
+    });
+
+    it('should queue low-priority file-shared during DND', () => {
+      dnd.setManual(60_000);
+
+      const event: TriggerEvent = {
+        triggerId: 'file-shared',
+        connectorId: 'drive',
+        data: { fileName: 'notes.txt', sharedBy: 'Carol' },
+        timestamp: Date.now(),
+      };
+
+      orchestrator.processTriggerEvents([event]);
+
+      expect(delivered).toHaveLength(0);
+      expect(orchestrator.getPending()).toHaveLength(1);
+    });
+  });
+
+  describe('processCalendarCheck', () => {
+    it('should create notifications for events starting within alert window', () => {
+      const now = Date.now();
+      const events = [
+        { title: 'Team standup', startTime: now + 10 * 60_000 }, // 10 min
+      ];
+
+      const results = orchestrator.processCalendarCheck(events, now);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].priority).toBe('important');
+      expect(results[0].message).toContain('Team standup');
+      expect(results[0].message).toContain('10 minutes');
+    });
+
+    it('should ignore events beyond the alert window', () => {
+      const now = Date.now();
+      const events = [
+        { title: 'Later meeting', startTime: now + 60 * 60_000 }, // 60 min
+      ];
+
+      const results = orchestrator.processCalendarCheck(events, now);
+      expect(results).toHaveLength(0);
+    });
+
+    it('should ignore events that have already started', () => {
+      const now = Date.now();
+      const events = [
+        { title: 'Past event', startTime: now - 5 * 60_000 },
+      ];
+
+      const results = orchestrator.processCalendarCheck(events, now);
+      expect(results).toHaveLength(0);
+    });
+
+    it('should use singular "minute" for 1 minute', () => {
+      const now = Date.now();
+      const events = [
+        { title: 'Quick sync', startTime: now + 60_000 }, // 1 min
+      ];
+
+      const results = orchestrator.processCalendarCheck(events, now);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].message).toContain('1 minute');
+      expect(results[0].message).not.toContain('1 minutes');
+    });
+
+    it('should respect custom calendar alert window', () => {
+      const customOrch = new NotificationOrchestrator(hub, dnd, deliveryChannel, {
+        calendarAlertWindowMs: 5 * 60_000, // 5 minutes
+      });
+
+      const now = Date.now();
+      const events = [
+        { title: 'Soon event', startTime: now + 3 * 60_000 },   // 3 min — within
+        { title: 'Later event', startTime: now + 10 * 60_000 },  // 10 min — outside
+      ];
+
+      const results = customOrch.processCalendarCheck(events, now);
+      expect(results).toHaveLength(1);
+      expect(results[0].message).toContain('Soon event');
+    });
+
+    it('should send calendar notifications to the hub', () => {
+      const now = Date.now();
+      const events = [
+        { title: 'Sync', startTime: now + 5 * 60_000 },
+      ];
+
+      orchestrator.processCalendarCheck(events, now);
+
+      const hubNotifications = hub.getAll();
+      expect(hubNotifications).toHaveLength(1);
+      expect(hubNotifications[0].source).toBe('calendar');
+      expect(hubNotifications[0].priority).toBe('important');
+    });
+  });
+
+  describe('getPending and dismiss', () => {
+    it('should return empty array when no pending notifications', () => {
+      expect(orchestrator.getPending()).toHaveLength(0);
+    });
+
+    it('should dismiss a pending notification by ID', () => {
+      dnd.setManual(60_000);
+
+      const event: TriggerEvent = {
+        triggerId: 'file-shared',
+        connectorId: 'drive',
+        data: { fileName: 'test.txt', sharedBy: 'Dan' },
+        timestamp: Date.now(),
+      };
+
+      orchestrator.processTriggerEvents([event]);
+      const pending = orchestrator.getPending();
+      expect(pending).toHaveLength(1);
+
+      const dismissed = orchestrator.dismiss(pending[0].id);
+      expect(dismissed).toBe(true);
+      expect(orchestrator.getPending()).toHaveLength(0);
+    });
+
+    it('should return false when dismissing unknown ID', () => {
+      expect(orchestrator.dismiss('nonexistent-id')).toBe(false);
+    });
+
+    it('should not include delivered notifications in pending', () => {
+      const event: TriggerEvent = {
+        triggerId: 'new-email',
+        connectorId: 'email',
+        data: { subject: 'Hello', from: 'a@b.com' },
+        timestamp: Date.now(),
+      };
+
+      orchestrator.processTriggerEvents([event]);
+
+      // Delivered notifications should not appear in pending
+      expect(orchestrator.getPending()).toHaveLength(0);
+      expect(delivered).toHaveLength(1);
+    });
+  });
+});

package/tests/scheduler.test.ts

@@ -0,0 +1,310 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { AmbientScheduler, DEFAULT_AMBIENT_SCHEDULER_CONFIG } from '../src/scheduler.js';
+import { BriefingGenerator, formatBriefingAsText } from '../src/briefing.js';
+import type { AmbientSchedulerDeps } from '../src/scheduler.js';
+import type { Briefing } from '../src/briefing.js';
+
+function createMockScheduler() {
+  const jobs = new Map<string, { cron: string; callback: () => void }>();
+  return {
+    schedule: vi.fn((id: string, cron: string, callback: () => void) => {
+      jobs.set(id, { cron, callback });
+    }),
+    stop: vi.fn((id: string) => {
+      jobs.delete(id);
+    }),
+    stopAll: vi.fn(() => jobs.clear()),
+    isScheduled: vi.fn((id: string) => jobs.has(id)),
+    listScheduled: vi.fn(() => Array.from(jobs.keys())),
+    _jobs: jobs,
+  };
+}
+
+function createMockDeps(overrides?: Partial<AmbientSchedulerDeps>): AmbientSchedulerDeps & { _scheduler: ReturnType<typeof createMockScheduler> } {
+  const scheduler = createMockScheduler();
+  const deps: AmbientSchedulerDeps = {
+    scheduler: scheduler as any,
+    connectorRegistry: { get: vi.fn(), list: vi.fn(() => []), has: vi.fn() } as any,
+    triggerManager: { pollAll: vi.fn(async () => []), subscribe: vi.fn(), unsubscribe: vi.fn() } as any,
+    briefingGenerator: new BriefingGenerator(),
+    deliveryChannel: vi.fn(async () => {}),
+    userId: 'test-user',
+    ...overrides,
+  };
+  return { ...deps, _scheduler: scheduler };
+}
+
+describe('AmbientScheduler', () => {
+  let deps: ReturnType<typeof createMockDeps>;
+  let scheduler: AmbientScheduler;
+
+  beforeEach(() => {
+    deps = createMockDeps();
+    scheduler = new AmbientScheduler(deps);
+  });
+
+  it('should not be running initially', () => {
+    expect(scheduler.isRunning()).toBe(false);
+  });
+
+  it('should schedule 5 cron jobs on start', () => {
+    scheduler.start();
+    expect(deps._scheduler.schedule).toHaveBeenCalledTimes(5);
+    expect(scheduler.isRunning()).toBe(true);
+  });
+
+  it('should schedule jobs with correct cron expressions', () => {
+    scheduler.start();
+    const calls = deps._scheduler.schedule.mock.calls;
+    const jobMap = new Map(calls.map((c: any[]) => [c[0], c[1]]));
+    expect(jobMap.get('ambient:email-poll')).toBe('*/2 * * * *');
+    expect(jobMap.get('ambient:calendar-poll')).toBe('*/5 * * * *');
+    expect(jobMap.get('ambient:morning-briefing')).toBe('0 7 * * *');
+    expect(jobMap.get('ambient:evening-summary')).toBe('0 18 * * *');
+    expect(jobMap.get('ambient:notification-poll')).toBe('*/1 * * * *');
+  });
+
+  it('should use custom cron expressions from config', () => {
+    const custom = createMockDeps({
+      config: { morningCron: '0 6 * * *', eveningCron: '0 20 * * *' },
+    });
+    const s = new AmbientScheduler(custom);
+    s.start();
+    const calls = custom._scheduler.schedule.mock.calls;
+    const jobMap = new Map(calls.map((c: any[]) => [c[0], c[1]]));
+    expect(jobMap.get('ambient:morning-briefing')).toBe('0 6 * * *');
+    expect(jobMap.get('ambient:evening-summary')).toBe('0 20 * * *');
+  });
+
+  it('should not start if disabled', () => {
+    const disabled = createMockDeps({ config: { enabled: false } });
+    const s = new AmbientScheduler(disabled);
+    s.start();
+    expect(disabled._scheduler.schedule).not.toHaveBeenCalled();
+    expect(s.isRunning()).toBe(false);
+  });
+
+  it('should not start twice', () => {
+    scheduler.start();
+    scheduler.start();
+    expect(deps._scheduler.schedule).toHaveBeenCalledTimes(5);
+  });
+
+  it('should stop all jobs', () => {
+    scheduler.start();
+    scheduler.stop();
+    expect(deps._scheduler.stop).toHaveBeenCalledTimes(5);
+    expect(scheduler.isRunning()).toBe(false);
+  });
+
+  it('should return config', () => {
+    const config = scheduler.getConfig();
+    expect(config.morningCron).toBe(DEFAULT_AMBIENT_SCHEDULER_CONFIG.morningCron);
+    expect(config.enabled).toBe(true);
+  });
+
+  it('should poll triggers when email poll fires', () => {
+    scheduler.start();
+    const emailPoll = deps._scheduler._jobs.get('ambient:email-poll');
+    emailPoll!.callback();
+    expect(deps.triggerManager.pollAll).toHaveBeenCalled();
+  });
+
+  it('should generate and deliver morning briefing', async () => {
+    scheduler.start();
+    await scheduler.generateAndDeliverBriefing('morning');
+    expect(deps.deliveryChannel).toHaveBeenCalledTimes(1);
+    const delivered = (deps.deliveryChannel as any).mock.calls[0][0] as string;
+    expect(delivered).toContain('Good morning');
+  });
+
+  it('should generate and deliver evening briefing', async () => {
+    scheduler.start();
+    await scheduler.generateAndDeliverBriefing('evening');
+    expect(deps.deliveryChannel).toHaveBeenCalledTimes(1);
+    const delivered = (deps.deliveryChannel as any).mock.calls[0][0] as string;
+    expect(delivered).toContain('evening summary');
+  });
+
+  it('should include calendar events when calendarIntelligence is available', async () => {
+    const calDeps = createMockDeps({
+      calendarIntelligence: {
+        analyzeDay: vi.fn(async () => ({
+          events: [{ title: 'Team standup', time: '10:00' }],
+        })),
+      },
+    });
+    const s = new AmbientScheduler(calDeps);
+    await s.generateAndDeliverBriefing('morning');
+    const delivered = (calDeps.deliveryChannel as any).mock.calls[0][0] as string;
+    expect(delivered).toContain('Team standup');
+  });
+
+  it('should include email notifications when emailIntelligence is available', async () => {
+    const emailDeps = createMockDeps({
+      emailIntelligence: {
+        triage: {
+          getTriageSummary: vi.fn(async () => ({
+            items: [{ subject: 'Urgent: server down', priority: 'urgent' }],
+          })),
+        },
+      },
+    });
+    const s = new AmbientScheduler(emailDeps);
+    await s.generateAndDeliverBriefing('morning');
+    const delivered = (emailDeps.deliveryChannel as any).mock.calls[0][0] as string;
+    expect(delivered).toContain('Urgent: server down');
+  });
+
+  it('should handle calendar fetch errors gracefully', async () => {
+    const errorDeps = createMockDeps({
+      calendarIntelligence: {
+        analyzeDay: vi.fn(async () => { throw new Error('API error'); }),
+      },
+    });
+    const s = new AmbientScheduler(errorDeps);
+    await expect(s.generateAndDeliverBriefing('morning')).resolves.toBeUndefined();
+    expect(errorDeps.deliveryChannel).toHaveBeenCalled();
+  });
+
+  it('should handle email fetch errors gracefully', async () => {
+    const errorDeps = createMockDeps({
+      emailIntelligence: {
+        triage: {
+          getTriageSummary: vi.fn(async () => { throw new Error('API error'); }),
+        },
+      },
+    });
+    const s = new AmbientScheduler(errorDeps);
+    await expect(s.generateAndDeliverBriefing('morning')).resolves.toBeUndefined();
+    expect(errorDeps.deliveryChannel).toHaveBeenCalled();
+  });
+
+  it('should schedule notification poll job on start', () => {
+    scheduler.start();
+    const jobs = Array.from(deps._scheduler._jobs.keys());
+    expect(jobs).toContain('ambient:notification-poll');
+  });
+
+  it('should stop notification poll job on stop', () => {
+    scheduler.start();
+    scheduler.stop();
+    expect(deps._scheduler.stop).toHaveBeenCalledWith('ambient:notification-poll');
+  });
+
+  it('should call triggerManager.pollAll and orchestrator when notification poll fires', async () => {
+    const mockOrchestrator = {
+      processTriggerEvents: vi.fn(),
+      processCalendarCheck: vi.fn(),
+      getPending: vi.fn(() => []),
+      dismiss: vi.fn(),
+    };
+    const orchDeps = createMockDeps({
+      notificationOrchestrator: mockOrchestrator as any,
+    });
+    (orchDeps.triggerManager.pollAll as any).mockResolvedValue([
+      { triggerId: 'new-email', connectorId: 'email', data: { subject: 'Test' }, timestamp: Date.now() },
+    ]);
+    const s = new AmbientScheduler(orchDeps);
+    s.start();
+
+    const pollJob = orchDeps._scheduler._jobs.get('ambient:notification-poll');
+    pollJob!.callback();
+
+    // Wait for async pollAndNotify to complete
+    await vi.waitFor(() => {
+      expect(orchDeps.triggerManager.pollAll).toHaveBeenCalled();
+      expect(mockOrchestrator.processTriggerEvents).toHaveBeenCalledWith([
+        expect.objectContaining({ triggerId: 'new-email' }),
+      ]);
+    });
+  });
+
+  it('should not call orchestrator when no events are returned', async () => {
+    const mockOrchestrator = {
+      processTriggerEvents: vi.fn(),
+      processCalendarCheck: vi.fn(),
+      getPending: vi.fn(() => []),
+      dismiss: vi.fn(),
+    };
+    const orchDeps = createMockDeps({
+      notificationOrchestrator: mockOrchestrator as any,
+    });
+    (orchDeps.triggerManager.pollAll as any).mockResolvedValue([]);
+    const s = new AmbientScheduler(orchDeps);
+    s.start();
+
+    const pollJob = orchDeps._scheduler._jobs.get('ambient:notification-poll');
+    pollJob!.callback();
+
+    await vi.waitFor(() => {
+      expect(orchDeps.triggerManager.pollAll).toHaveBeenCalled();
+    });
+    expect(mockOrchestrator.processTriggerEvents).not.toHaveBeenCalled();
+  });
+
+  it('should skip notification polling when orchestrator is not provided', async () => {
+    scheduler.start();
+    const pollJob = deps._scheduler._jobs.get('ambient:notification-poll');
+    pollJob!.callback();
+    // Should not throw; pollAll should not be called since orchestrator is absent
+    await vi.waitFor(() => {
+      expect(deps.triggerManager.pollAll).not.toHaveBeenCalled();
+    });
+  });
+});
+
+describe('formatBriefingAsText', () => {
+  it('should format a morning briefing', () => {
+    const briefing: Briefing = {
+      userId: 'user1',
+      generatedAt: Date.now(),
+      timeOfDay: 'morning',
+      sections: [
+        { title: "Today's Schedule", items: ['10:00 - Standup', '12:00 - Lunch'] },
+        { title: 'Active Tasks', items: ['Review PR (in-progress)'] },
+      ],
+    };
+    const text = formatBriefingAsText(briefing);
+    expect(text).toContain('Good morning');
+    expect(text).toContain("Today's Schedule");
+    expect(text).toContain('  10:00 - Standup');
+    expect(text).toContain('  12:00 - Lunch');
+    expect(text).toContain('Active Tasks');
+    expect(text).toContain('  Review PR (in-progress)');
+  });
+
+  it('should format an evening briefing', () => {
+    const briefing: Briefing = {
+      userId: 'user1',
+      generatedAt: Date.now(),
+      timeOfDay: 'evening',
+      sections: [{ title: "Tomorrow's Schedule", items: ['09:00 - Sprint planning'] }],
+    };
+    const text = formatBriefingAsText(briefing);
+    expect(text).toContain('evening summary');
+    expect(text).toContain("Tomorrow's Schedule");
+  });
+
+  it('should format a custom briefing', () => {
+    const briefing: Briefing = {
+      userId: 'user1',
+      generatedAt: Date.now(),
+      timeOfDay: 'custom',
+      sections: [{ title: 'Updates', items: ['Item 1'] }],
+    };
+    const text = formatBriefingAsText(briefing);
+    expect(text).toContain('Here\'s your briefing:');
+  });
+
+  it('should handle empty sections', () => {
+    const briefing: Briefing = {
+      userId: 'user1',
+      generatedAt: Date.now(),
+      timeOfDay: 'morning',
+      sections: [],
+    };
+    const text = formatBriefingAsText(briefing);
+    expect(text).toContain('No updates right now');
+  });
+});

package/tests/wiring.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest';
+
+describe('Ambient package exports', () => {
+  it('should export all public APIs', async () => {
+    const mod = await import('../src/index.js');
+    expect(mod.AmbientPatternEngine).toBeDefined();
+    expect(mod.AnticipationEngine).toBeDefined();
+    expect(mod.BriefingGenerator).toBeDefined();
+    expect(mod.QuietNotificationManager).toBeDefined();
+    expect(mod.DEFAULT_BRIEFING_CONFIG).toBeDefined();
+  });
+});

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "references": [
+    { "path": "../behaviors" },
+    { "path": "../memory" },
+    { "path": "../connectors" },
+    { "path": "../notification-hub" },
+    { "path": "../personality" }
+  ]
+}