groove-dev 0.27.14 → 0.27.17

package/node_modules/@groove-dev/daemon/templates/toys-catalog.json

@@ -0,0 +1,242 @@
+[
+  {
+    "id": "nasa-eonet",
+    "name": "NASA Earth Observatory",
+    "description": "Track natural events on Earth in real-time — wildfires, storms, volcanic eruptions, and more from NASA's EONET feed.",
+    "category": "space",
+    "icon": "Globe",
+    "docsUrl": "https://eonet.gsfc.nasa.gov/docs/v3",
+    "baseUrl": "https://eonet.gsfc.nasa.gov/api/v3",
+    "authType": "apiKey",
+    "keyHeader": "api_key",
+    "sampleEndpoints": [
+      "GET /events",
+      "GET /events?status=open",
+      "GET /categories",
+      "GET /events?category=wildfires"
+    ],
+    "starterPrompts": [
+      "Build a live wildfire tracker with map visualization",
+      "Create a natural disaster dashboard with event timelines",
+      "Build an alert system for volcanic eruptions near populated areas",
+      "Visualize storm patterns across the globe over the last 30 days"
+    ],
+    "difficulty": "intermediate"
+  },
+  {
+    "id": "nasa-apod",
+    "name": "NASA Astronomy Picture of the Day",
+    "description": "Access NASA's iconic daily astronomy images and explanations — one stunning space photo every day since 1995.",
+    "category": "space",
+    "icon": "Globe",
+    "docsUrl": "https://api.nasa.gov",
+    "baseUrl": "https://api.nasa.gov/planetary",
+    "authType": "apiKey",
+    "keyHeader": "api_key",
+    "sampleEndpoints": [
+      "GET /apod?api_key=DEMO_KEY",
+      "GET /apod?date=2024-01-01",
+      "GET /apod?start_date=2024-01-01&end_date=2024-01-07",
+      "GET /apod?count=5"
+    ],
+    "starterPrompts": [
+      "Build a space photo gallery with daily updates",
+      "Create a screensaver app that cycles through APOD images",
+      "Build a quiz game using astronomy photo descriptions",
+      "Make a calendar app with a space photo for each day"
+    ],
+    "difficulty": "beginner"
+  },
+  {
+    "id": "openweathermap",
+    "name": "OpenWeatherMap",
+    "description": "Get current weather, forecasts, and historical data for any location on Earth with this popular weather API.",
+    "category": "weather",
+    "icon": "Cloud",
+    "docsUrl": "https://openweathermap.org/api",
+    "baseUrl": "https://api.openweathermap.org/data/2.5",
+    "authType": "apiKey",
+    "keyHeader": "appid",
+    "sampleEndpoints": [
+      "GET /weather?q=London&appid=KEY",
+      "GET /forecast?q=Tokyo&appid=KEY",
+      "GET /weather?lat=40.7&lon=-74.0&appid=KEY",
+      "GET /air_pollution?lat=50&lon=50&appid=KEY"
+    ],
+    "starterPrompts": [
+      "Build a weather dashboard with 5-day forecasts",
+      "Create a travel planner that suggests destinations by weather",
+      "Build an air quality monitor for major cities",
+      "Make a weather comparison tool for two cities side by side"
+    ],
+    "difficulty": "beginner"
+  },
+  {
+    "id": "coingecko",
+    "name": "CoinGecko",
+    "description": "Free crypto market data — prices, market caps, volumes, and trending coins across thousands of cryptocurrencies.",
+    "category": "finance",
+    "icon": "Coins",
+    "docsUrl": "https://docs.coingecko.com/v3",
+    "baseUrl": "https://api.coingecko.com/api/v3",
+    "authType": "none",
+    "keyHeader": null,
+    "sampleEndpoints": [
+      "GET /simple/price?ids=bitcoin&vs_currencies=usd",
+      "GET /coins/markets?vs_currency=usd&order=market_cap_desc",
+      "GET /search/trending",
+      "GET /coins/bitcoin/market_chart?vs_currency=usd&days=30"
+    ],
+    "starterPrompts": [
+      "Build a crypto portfolio tracker with live prices",
+      "Create a trending coins dashboard with price charts",
+      "Build a price alert system for your favorite coins",
+      "Make a crypto market overview with top gainers and losers"
+    ],
+    "difficulty": "beginner"
+  },
+  {
+    "id": "alpha-vantage",
+    "name": "Alpha Vantage",
+    "description": "Stock market data, forex, and crypto through a powerful financial API — real-time and historical time series.",
+    "category": "finance",
+    "icon": "Coins",
+    "docsUrl": "https://www.alphavantage.co/documentation",
+    "baseUrl": "https://www.alphavantage.co",
+    "authType": "apiKey",
+    "keyHeader": "apikey",
+    "sampleEndpoints": [
+      "GET /query?function=TIME_SERIES_DAILY&symbol=AAPL&apikey=KEY",
+      "GET /query?function=GLOBAL_QUOTE&symbol=MSFT&apikey=KEY",
+      "GET /query?function=SYMBOL_SEARCH&keywords=tesla&apikey=KEY",
+      "GET /query?function=NEWS_SENTIMENT&tickers=AAPL&apikey=KEY"
+    ],
+    "starterPrompts": [
+      "Build a stock screener with technical indicators",
+      "Create a portfolio analyzer with historical performance charts",
+      "Build a stock news sentiment tracker",
+      "Make a comparison tool for multiple stocks over time"
+    ],
+    "difficulty": "intermediate"
+  },
+  {
+    "id": "pokeapi",
+    "name": "PokeAPI",
+    "description": "The complete Pokemon encyclopedia API — every Pokemon, move, ability, and item from all generations.",
+    "category": "fun",
+    "icon": "Gamepad2",
+    "docsUrl": "https://pokeapi.co/docs/v2",
+    "baseUrl": "https://pokeapi.co/api/v2",
+    "authType": "none",
+    "keyHeader": null,
+    "sampleEndpoints": [
+      "GET /pokemon/pikachu",
+      "GET /pokemon?limit=20&offset=0",
+      "GET /type/fire",
+      "GET /ability/overgrow"
+    ],
+    "starterPrompts": [
+      "Build a Pokedex with search and type filtering",
+      "Create a Pokemon battle simulator",
+      "Build a team builder that suggests balanced teams",
+      "Make a Pokemon quiz game with sprites and stats"
+    ],
+    "difficulty": "beginner"
+  },
+  {
+    "id": "open-trivia-db",
+    "name": "Open Trivia DB",
+    "description": "Free trivia question database with thousands of questions across dozens of categories and difficulty levels.",
+    "category": "fun",
+    "icon": "Gamepad2",
+    "docsUrl": "https://opentdb.com/api_config.php",
+    "baseUrl": "https://opentdb.com",
+    "authType": "none",
+    "keyHeader": null,
+    "sampleEndpoints": [
+      "GET /api.php?amount=10",
+      "GET /api.php?amount=10&category=9&difficulty=easy",
+      "GET /api_category.php",
+      "GET /api.php?amount=10&type=multiple"
+    ],
+    "starterPrompts": [
+      "Build a multiplayer trivia game with scoreboards",
+      "Create a daily trivia challenge with streaks",
+      "Build a study tool that quizzes you on specific topics",
+      "Make a trivia night host app with rounds and scoring"
+    ],
+    "difficulty": "beginner"
+  },
+  {
+    "id": "nominatim-osm",
+    "name": "Nominatim / OpenStreetMap",
+    "description": "Free geocoding and reverse geocoding powered by OpenStreetMap — turn addresses into coordinates and back.",
+    "category": "maps",
+    "icon": "Map",
+    "docsUrl": "https://nominatim.org/release-docs/develop/api/Overview",
+    "baseUrl": "https://nominatim.openstreetmap.org",
+    "authType": "none",
+    "keyHeader": null,
+    "sampleEndpoints": [
+      "GET /search?q=London&format=json",
+      "GET /reverse?lat=51.5&lon=-0.1&format=json",
+      "GET /search?q=restaurants+near+times+square&format=json",
+      "GET /lookup?osm_ids=R146656&format=json"
+    ],
+    "starterPrompts": [
+      "Build a location search tool with map preview",
+      "Create a distance calculator between any two places",
+      "Build a geocoding batch tool for CSV address lists",
+      "Make a neighborhood explorer that shows nearby points of interest"
+    ],
+    "difficulty": "beginner"
+  },
+  {
+    "id": "jsonplaceholder",
+    "name": "JSONPlaceholder",
+    "description": "A free fake REST API for testing and prototyping — perfect for learning HTTP requests with realistic data.",
+    "category": "data",
+    "icon": "Database",
+    "docsUrl": "https://jsonplaceholder.typicode.com/guide",
+    "baseUrl": "https://jsonplaceholder.typicode.com",
+    "authType": "none",
+    "keyHeader": null,
+    "sampleEndpoints": [
+      "GET /posts",
+      "GET /users/1",
+      "GET /posts/1/comments",
+      "POST /posts"
+    ],
+    "starterPrompts": [
+      "Build a social media feed with posts and comments",
+      "Create a user directory with profile cards",
+      "Build a todo app backed by the API",
+      "Make a blog engine with CRUD operations"
+    ],
+    "difficulty": "beginner"
+  },
+  {
+    "id": "the-dog-api",
+    "name": "The Dog API",
+    "description": "Browse every dog breed with images, temperaments, and stats — a fun API for dog lovers and quick prototypes.",
+    "category": "fun",
+    "icon": "Gamepad2",
+    "docsUrl": "https://docs.thedogapi.com",
+    "baseUrl": "https://api.thedogapi.com/v1",
+    "authType": "none",
+    "keyHeader": null,
+    "sampleEndpoints": [
+      "GET /breeds",
+      "GET /images/search?limit=10",
+      "GET /breeds/search?q=labrador",
+      "GET /breeds?limit=10&page=0"
+    ],
+    "starterPrompts": [
+      "Build a dog breed encyclopedia with photos",
+      "Create a random dog image gallery",
+      "Build a dog breed quiz — guess the breed from the photo",
+      "Make a dog breed comparison tool with stats and images"
+    ],
+    "difficulty": "beginner"
+  }
+]

package/node_modules/@groove-dev/daemon/test/classifier.test.js

@@ -94,4 +94,102 @@ describe('TaskClassifier', () => {
     classifier.clearAgent('agent-1');
     assert.equal(classifier.classify('agent-1'), 'medium');
   });
+
+  describe('getUpdates()', () => {
+    it('should return empty when no agents have 40+ events', () => {
+      for (let i = 0; i < 39; i++) {
+        classifier.addEvent('agent-1', { type: 'tool', tool: 'Read', input: `file${i}.js` });
+      }
+      const updates = classifier.getUpdates();
+      assert.equal(updates.length, 0);
+    });
+
+    it('should return classification when agent has enough events', () => {
+      for (let i = 0; i < 45; i++) {
+        classifier.addEvent('agent-1', { type: 'tool', tool: 'Read', input: `file${i}.js` });
+      }
+      const updates = classifier.getUpdates();
+      assert.equal(updates.length, 1);
+      assert.equal(updates[0].agentId, 'agent-1');
+      assert.equal(updates[0].tier, 'light');
+      assert.equal(updates[0].eventCount, 45);
+    });
+
+    it('should only report changes — no repeat when tier and count stable', () => {
+      for (let i = 0; i < 45; i++) {
+        classifier.addEvent('agent-1', { type: 'tool', tool: 'Read', input: `file${i}.js` });
+      }
+      // First call reports
+      const first = classifier.getUpdates();
+      assert.equal(first.length, 1);
+
+      // Second call with no new events — no report
+      const second = classifier.getUpdates();
+      assert.equal(second.length, 0);
+    });
+
+    it('should report again when tier changes', () => {
+      // Start with read-only (light)
+      for (let i = 0; i < 45; i++) {
+        classifier.addEvent('agent-1', { type: 'tool', tool: 'Read', input: `file${i}.js` });
+      }
+      classifier.getUpdates(); // consume initial report
+
+      // Add heavy signals to shift classification
+      for (let i = 0; i < 50; i++) {
+        classifier.addEvent('agent-1', { type: 'error', text: 'TypeError: undefined' });
+      }
+      const updates = classifier.getUpdates();
+      assert.equal(updates.length, 1);
+      assert.equal(updates[0].tier, 'heavy');
+    });
+
+    it('should report again when event count delta reaches 20', () => {
+      for (let i = 0; i < 45; i++) {
+        classifier.addEvent('agent-1', { type: 'tool', tool: 'Read', input: `file${i}.js` });
+      }
+      classifier.getUpdates(); // consume initial report (eventCount=45)
+
+      // Add 20 more events (same tier, but eventCount delta = 20)
+      for (let i = 0; i < 20; i++) {
+        classifier.addEvent('agent-1', { type: 'tool', tool: 'Read', input: `extra${i}.js` });
+      }
+      const updates = classifier.getUpdates();
+      assert.equal(updates.length, 1);
+      assert.equal(updates[0].eventCount, 65);
+    });
+
+    it('should not report when event count delta is less than 20', () => {
+      for (let i = 0; i < 45; i++) {
+        classifier.addEvent('agent-1', { type: 'tool', tool: 'Read', input: `file${i}.js` });
+      }
+      classifier.getUpdates(); // consume initial report (eventCount=45)
+
+      // Add only 10 more events — delta < 20, same tier
+      for (let i = 0; i < 10; i++) {
+        classifier.addEvent('agent-1', { type: 'tool', tool: 'Read', input: `extra${i}.js` });
+      }
+      const updates = classifier.getUpdates();
+      assert.equal(updates.length, 0);
+    });
+  });
+
+  describe('clearAgent() broadcast state', () => {
+    it('should clear broadcast state so next getUpdates reports fresh', () => {
+      for (let i = 0; i < 45; i++) {
+        classifier.addEvent('agent-1', { type: 'tool', tool: 'Read', input: `file${i}.js` });
+      }
+      classifier.getUpdates(); // consume initial report
+
+      // Clear and re-populate
+      classifier.clearAgent('agent-1');
+      assert.equal(classifier._lastBroadcast['agent-1'], undefined);
+
+      for (let i = 0; i < 45; i++) {
+        classifier.addEvent('agent-1', { type: 'tool', tool: 'Read', input: `file${i}.js` });
+      }
+      const updates = classifier.getUpdates();
+      assert.equal(updates.length, 1); // Reports again because broadcast state was cleared
+    });
+  });
 });

package/node_modules/@groove-dev/daemon/test/introducer.test.js

@@ -6,7 +6,8 @@ import assert from 'node:assert/strict';
 import { Introducer } from '../src/introducer.js';
 import { Registry } from '../src/registry.js';
 import { StateManager } from '../src/state.js';
-import { mkdtempSync, readFileSync, writeFileSync, existsSync } from 'fs';
+import { MemoryStore } from '../src/memory.js';
+import { mkdtempSync, readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
 
@@ -92,6 +93,76 @@ describe('Introducer', () => {
     });
   });
 
+  describe('Layer 7 memory injection', () => {
+    it('should append memory section at end of context when memory exists', () => {
+      const grooveDir = join(tmpDir, '.groove');
+      mkdirSync(grooveDir, { recursive: true });
+      const memory = new MemoryStore(grooveDir);
+      memory.addConstraint({ text: 'Never modify packages/daemon/index.js directly', category: 'hard' });
+      memory.addDiscovery({ role: 'backend', trigger: 'Cannot find module X', fix: 'npm install X', outcome: 'success' });
+
+      const daemon = { registry, projectDir: tmpDir, grooveDir, memory };
+      const intro = new Introducer(daemon);
+
+      const agent = registry.add({ role: 'backend', scope: ['src/api/**'] });
+      const ctx = intro.generateContext(agent, { hasTask: true });
+
+      assert.ok(ctx.includes('## Project Memory (auto-generated)'));
+      assert.ok(ctx.includes('Constraints (read carefully)'));
+      assert.ok(ctx.includes('Never modify packages/daemon/index.js'));
+      assert.ok(ctx.includes('Known Fixes for backend Role'));
+      assert.ok(ctx.includes('Cannot find module X'));
+    });
+
+    it('should not inject memory section when memory is empty', () => {
+      const grooveDir = join(tmpDir, '.groove');
+      mkdirSync(grooveDir, { recursive: true });
+      const memory = new MemoryStore(grooveDir);
+
+      const daemon = { registry, projectDir: tmpDir, grooveDir, memory };
+      const intro = new Introducer(daemon);
+
+      const agent = registry.add({ role: 'backend', scope: [] });
+      const ctx = intro.generateContext(agent);
+
+      assert.ok(!ctx.includes('## Project Memory'));
+    });
+
+    it('should not break spawn when memory is unavailable', () => {
+      const daemon = { registry, projectDir: tmpDir, grooveDir: tmpDir, memory: null };
+      const intro = new Introducer(daemon);
+
+      const agent = registry.add({ role: 'backend', scope: [] });
+      const ctx = intro.generateContext(agent);
+
+      // Should produce valid context without memory section
+      assert.ok(ctx.includes('backend'));
+      assert.ok(!ctx.includes('## Project Memory'));
+    });
+
+    it('should enforce 4K character budget on memory section', () => {
+      const grooveDir = join(tmpDir, '.groove');
+      mkdirSync(grooveDir, { recursive: true });
+      const memory = new MemoryStore(grooveDir);
+      // Add many constraints to exceed budget
+      for (let i = 0; i < 40; i++) {
+        memory.addConstraint({ text: `Rule ${i}: never touch file-${i}.config.js in the project root directory`, category: 'hard' });
+      }
+
+      const daemon = { registry, projectDir: tmpDir, grooveDir, memory };
+      const intro = new Introducer(daemon);
+
+      const agent = registry.add({ role: 'backend', scope: [] });
+      const ctx = intro.generateContext(agent);
+
+      // Memory section should exist but be truncated
+      const memStart = ctx.indexOf('## Project Memory');
+      assert.ok(memStart !== -1);
+      const memSection = ctx.slice(memStart);
+      assert.ok(memSection.length <= 4003); // 4000 + "..." adjustment
+    });
+  });
+
   describe('CLAUDE.md injection', () => {
     it('should inject GROOVE section into existing CLAUDE.md', () => {
       writeFileSync(join(tmpDir, 'CLAUDE.md'), '# My Project\n\nSome content.\n');

package/node_modules/@groove-dev/daemon/test/journalist.test.js

@@ -6,6 +6,7 @@ import assert from 'node:assert/strict';
 import { Journalist } from '../src/journalist.js';
 import { Registry } from '../src/registry.js';
 import { StateManager } from '../src/state.js';
+import { MemoryStore } from '../src/memory.js';
 import { mkdtempSync, writeFileSync, existsSync, readFileSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
@@ -252,4 +253,120 @@ describe('Journalist', () => {
       assert.equal(status.running, false);
     });
   });
+
+  describe('_extractDiscoveries', () => {
+    it('should extract error→fix pairs from filtered logs', () => {
+      const { daemon, grooveDir } = createMockDaemon();
+      daemon.memory = new MemoryStore(grooveDir);
+      const journalist = new Journalist(daemon);
+
+      const filteredLogs = {
+        a1: {
+          agent: { id: 'a1', role: 'backend' },
+          entries: [
+            { type: 'error', text: 'Error: Cannot find module gray-matter' },
+            { type: 'tool', tool: 'Edit', input: 'package.json — added gray-matter dependency' },
+          ],
+          explorationEntries: [],
+        },
+      };
+
+      journalist._extractDiscoveries(filteredLogs);
+
+      const discoveries = daemon.memory.listDiscoveries();
+      assert.equal(discoveries.length, 1);
+      assert.ok(discoveries[0].trigger.includes('Cannot find module'));
+      assert.ok(discoveries[0].fix.includes('package.json'));
+    });
+
+    it('should not crash when memory is unavailable', () => {
+      const { daemon } = createMockDaemon();
+      daemon.memory = null;
+      const journalist = new Journalist(daemon);
+
+      // Should not throw
+      journalist._extractDiscoveries({
+        a1: { agent: { id: 'a1', role: 'backend' }, entries: [], explorationEntries: [] },
+      });
+    });
+
+    it('should skip entries without error signals', () => {
+      const { daemon, grooveDir } = createMockDaemon();
+      daemon.memory = new MemoryStore(grooveDir);
+      const journalist = new Journalist(daemon);
+
+      const filteredLogs = {
+        a1: {
+          agent: { id: 'a1', role: 'backend' },
+          entries: [
+            { type: 'tool', tool: 'Write', input: 'src/index.js' },
+            { type: 'tool', tool: 'Edit', input: 'src/api.js' },
+          ],
+          explorationEntries: [],
+        },
+      };
+
+      journalist._extractDiscoveries(filteredLogs);
+      assert.equal(daemon.memory.listDiscoveries().length, 0);
+    });
+  });
+
+  describe('_extractConstraints', () => {
+    it('should no-op since auto-extraction is disabled', () => {
+      const { daemon, grooveDir } = createMockDaemon();
+      daemon.memory = new MemoryStore(grooveDir);
+      const journalist = new Journalist(daemon);
+
+      const filteredLogs = {
+        a1: {
+          agent: { id: 'a1', role: 'backend' },
+          entries: [
+            {
+              type: 'thinking',
+              text: 'I should never modify packages/daemon/index.js directly because it is auto-generated from the template',
+            },
+          ],
+          explorationEntries: [],
+        },
+      };
+
+      journalist._extractConstraints(filteredLogs);
+
+      const constraints = daemon.memory.listConstraints();
+      assert.equal(constraints.length, 0);
+    });
+
+    it('should skip non-project-specific constraints', () => {
+      const { daemon, grooveDir } = createMockDaemon();
+      daemon.memory = new MemoryStore(grooveDir);
+      const journalist = new Journalist(daemon);
+
+      const filteredLogs = {
+        a1: {
+          agent: { id: 'a1', role: 'backend' },
+          entries: [
+            {
+              type: 'thinking',
+              text: 'I must always write clean code and follow best practices for readability',
+            },
+          ],
+          explorationEntries: [],
+        },
+      };
+
+      journalist._extractConstraints(filteredLogs);
+      // Generic advice should be skipped (no file/config references)
+      assert.equal(daemon.memory.listConstraints().length, 0);
+    });
+
+    it('should not crash when memory is unavailable', () => {
+      const { daemon } = createMockDaemon();
+      daemon.memory = null;
+      const journalist = new Journalist(daemon);
+
+      journalist._extractConstraints({
+        a1: { agent: { id: 'a1', role: 'backend' }, entries: [], explorationEntries: [] },
+      });
+    });
+  });
 });

package/node_modules/@groove-dev/daemon/test/memory.test.js

@@ -142,9 +142,45 @@ describe('MemoryStore', () => {
     it('sanitizes role names for filesystem safety', () => {
       const ok = memory.appendHandoffBrief('../evil/role', { brief: 'test' });
       assert.equal(ok, true);
-      // File should be created with safe name, no path traversal
       assert.ok(existsSync(tmpDir));
     });
+
+    it('scopes chains by workspace', () => {
+      const wsA = join(tmpDir, '..', 'electron-app');
+      const wsB = join(tmpDir, '..', 'agents-team');
+      memory.appendHandoffBrief('backend', { brief: 'electron backend work' }, wsA);
+      memory.appendHandoffBrief('backend', { brief: 'agents backend work' }, wsB);
+
+      const chainA = memory.getHandoffChain('backend', wsA);
+      const chainB = memory.getHandoffChain('backend', wsB);
+      assert.equal(chainA.length, 1);
+      assert.equal(chainB.length, 1);
+      assert.match(chainA[0].body, /electron backend/);
+      assert.match(chainB[0].body, /agents backend/);
+    });
+
+    it('workspace chains are independent from root chains', () => {
+      const ws = join(tmpDir, '..', 'my-workspace');
+      memory.appendHandoffBrief('frontend', { brief: 'root work' });
+      memory.appendHandoffBrief('frontend', { brief: 'workspace work' }, ws);
+
+      assert.equal(memory.getHandoffChain('frontend').length, 1);
+      assert.equal(memory.getHandoffChain('frontend', ws).length, 1);
+      assert.match(memory.getRecentHandoffMarkdown('frontend'), /root work/);
+      assert.match(memory.getRecentHandoffMarkdown('frontend', 3, 4000, ws), /workspace work/);
+    });
+
+    it('listHandoffRoles scoped to workspace', () => {
+      const ws = join(tmpDir, '..', 'electron-app');
+      memory.appendHandoffBrief('backend', { brief: 'root' });
+      memory.appendHandoffBrief('frontend', { brief: 'ws' }, ws);
+
+      const rootRoles = memory.listHandoffRoles();
+      const wsRoles = memory.listHandoffRoles(ws);
+      assert.ok(rootRoles.includes('backend'));
+      assert.ok(!rootRoles.includes('frontend'));
+      assert.ok(wsRoles.includes('frontend'));
+    });
   });
 
   describe('discoveries', () => {