claude-code-swarm 0.0.1 → 0.3.3

package/references/openteams/editor/tests/e2e-export-roundtrip.test.ts

@@ -0,0 +1,299 @@
+/**
+ * E2E: Export/Import roundtrip
+ * Tests the full cycle: load template → modify → export YAML →
+ * re-import → verify state matches.
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import * as yaml from 'js-yaml';
+import { useCanvasStore } from '../src/stores/canvas-store';
+import { useConfigStore } from '../src/stores/config-store';
+import { useHistoryStore } from '../src/stores/history-store';
+import { useValidationStore } from '../src/stores/validation-store';
+import { BUNDLED_TEMPLATES } from '../src/lib/bundled-templates';
+import { loadTemplate } from '../src/lib/load-template';
+import { compileToYaml } from '../src/lib/compiler';
+import { configToCanvas, canvasToManifest, rolesToDefinitions } from '../src/lib/serializer';
+import type { TeamManifest, RoleDefinition } from '@openteams/template/types';
+import type { RoleNodeData } from '../src/types/editor';
+
+function resetStores() {
+  useCanvasStore.getState().clear();
+  useConfigStore.getState().clear();
+  useHistoryStore.getState().clear();
+  useValidationStore.getState().clear();
+}
+
+describe('E2E: Export/Import roundtrip', () => {
+  beforeEach(resetStores);
+
+  it('GSD template export produces valid team.yaml', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    const files = compileToYaml();
+    const teamFile = files.find(f => f.path === 'team.yaml');
+    expect(teamFile).toBeDefined();
+
+    const parsed = yaml.load(teamFile!.content) as TeamManifest;
+    expect(parsed.name).toBe('gsd');
+    expect(parsed.roles).toHaveLength(12);
+    expect(parsed.topology.root.role).toBe('orchestrator');
+  });
+
+  it('export produces role files for each role', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    const files = compileToYaml();
+    const roleFiles = files.filter(f => f.path.startsWith('roles/'));
+
+    // Should have one file per role
+    expect(roleFiles.length).toBe(12);
+
+    // Each should be valid YAML
+    for (const file of roleFiles) {
+      const parsed = yaml.load(file.content) as Record<string, unknown>;
+      expect(parsed).toBeDefined();
+      expect(parsed.name).toBeDefined();
+    }
+  });
+
+  it('roundtrip: load → export → re-import preserves roles', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    // Capture state after load
+    const originalRoleCount = useConfigStore.getState().roles.size;
+    const originalChannelCount = Object.keys(useConfigStore.getState().channels).length;
+
+    // Export
+    const files = compileToYaml();
+    const teamYaml = files.find(f => f.path === 'team.yaml')!.content;
+    const manifest = yaml.load(teamYaml) as TeamManifest;
+
+    // Build role definitions from role files
+    const roleMap = new Map<string, RoleDefinition>();
+    for (const file of files.filter(f => f.path.startsWith('roles/'))) {
+      const role = yaml.load(file.content) as RoleDefinition;
+      if (role?.name) roleMap.set(role.name, role);
+    }
+
+    // Re-import
+    resetStores();
+    loadTemplate(manifest, roleMap);
+
+    // Verify state matches
+    expect(useConfigStore.getState().roles.size).toBe(originalRoleCount);
+    expect(Object.keys(useConfigStore.getState().channels).length).toBe(originalChannelCount);
+    expect(useConfigStore.getState().team.name).toBe('gsd');
+  });
+
+  it('roundtrip preserves topology structure', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    const files = compileToYaml();
+    const manifest = yaml.load(files.find(f => f.path === 'team.yaml')!.content) as TeamManifest;
+
+    expect(manifest.topology.root.role).toBe('orchestrator');
+    expect(manifest.topology.companions?.map(c => c.role)).toContain('roadmapper');
+    expect(manifest.topology.companions?.map(c => c.role)).toContain('verifier');
+  });
+
+  it('roundtrip preserves communication channels', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    const files = compileToYaml();
+    const manifest = yaml.load(files.find(f => f.path === 'team.yaml')!.content) as TeamManifest;
+
+    expect(manifest.communication?.channels).toBeDefined();
+    expect(Object.keys(manifest.communication!.channels!)).toContain('project_lifecycle');
+    expect(manifest.communication!.channels!.project_lifecycle.signals).toContain('PROJECT_INITIALIZED');
+  });
+
+  it('roundtrip preserves peer routes', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    const originalRouteCount = useConfigStore.getState().peerRoutes.length;
+
+    const files = compileToYaml();
+    const manifest = yaml.load(files.find(f => f.path === 'team.yaml')!.content) as TeamManifest;
+
+    const exportedRouteCount = manifest.communication?.routing?.peers?.length || 0;
+    expect(exportedRouteCount).toBe(originalRouteCount);
+  });
+
+  it('roundtrip preserves spawn rules', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    const files = compileToYaml();
+    const manifest = yaml.load(files.find(f => f.path === 'team.yaml')!.content) as TeamManifest;
+
+    expect(manifest.topology.spawn_rules).toBeDefined();
+    expect(manifest.topology.spawn_rules!['orchestrator']).toHaveLength(11);
+  });
+
+  it('export after adding a role includes the new role', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    // Add a new role
+    const config = useConfigStore.getState();
+    config.setRole('custom-agent', {
+      name: 'custom-agent',
+      displayName: 'Custom Agent',
+      description: 'A custom agent',
+      capabilities: ['analyze'],
+    });
+    useCanvasStore.getState().addNode({
+      id: 'role-custom-agent',
+      type: 'role',
+      position: { x: 0, y: 0 },
+      data: {
+        kind: 'role',
+        roleName: 'custom-agent',
+        displayName: 'Custom Agent',
+        description: 'A custom agent',
+        topologyPosition: 'spawned',
+        capabilities: ['analyze'],
+        emits: [],
+        subscribesTo: [],
+        peerRoutesOut: 0,
+        peerRoutesIn: 0,
+        canSpawn: [],
+        errors: [],
+        warnings: [],
+      } as RoleNodeData,
+    });
+
+    const files = compileToYaml();
+    const manifest = yaml.load(files.find(f => f.path === 'team.yaml')!.content) as TeamManifest;
+
+    expect(manifest.roles).toContain('custom-agent');
+    expect(manifest.roles).toHaveLength(13);
+
+    const roleFile = files.find(f => f.path === 'roles/custom-agent.yaml');
+    expect(roleFile).toBeDefined();
+    const roleDef = yaml.load(roleFile!.content) as Record<string, unknown>;
+    expect(roleDef.name).toBe('custom-agent');
+    expect(roleDef.display_name).toBe('Custom Agent');
+    expect(roleDef.capabilities).toEqual(['analyze']);
+  });
+
+  it('export preserves model assignments', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    // Set a model
+    useConfigStore.getState().setRoleModel('orchestrator', 'opus');
+
+    const files = compileToYaml();
+    const manifest = yaml.load(files.find(f => f.path === 'team.yaml')!.content) as TeamManifest;
+
+    expect(manifest.topology.root.config?.model).toBe('opus');
+  });
+
+  it('export preserves enforcement mode', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    // Change enforcement
+    useConfigStore.getState().setTeam({ enforcement: 'strict' });
+
+    const files = compileToYaml();
+    const manifest = yaml.load(files.find(f => f.path === 'team.yaml')!.content) as TeamManifest;
+
+    expect(manifest.communication?.enforcement).toBe('strict');
+  });
+
+  it('export produces prompt files when content exists', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    // Add prompt content to a role
+    const config = useConfigStore.getState();
+    const role = config.roles.get('orchestrator')!;
+    config.setRole('orchestrator', {
+      ...role,
+      promptContent: '# Orchestrator\nYou coordinate the team.',
+    });
+
+    const files = compileToYaml();
+    const promptFile = files.find(f => f.path === 'prompts/orchestrator/ROLE.md');
+    expect(promptFile).toBeDefined();
+    expect(promptFile!.content).toContain('# Orchestrator');
+  });
+
+  it('configToCanvas and canvasToManifest are inverses', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+
+    // Forward: manifest → canvas
+    const canvasState = configToCanvas(tmpl.manifest, tmpl.roles);
+    expect(canvasState.nodes.length).toBeGreaterThan(0);
+    expect(canvasState.edges.length).toBeGreaterThan(0);
+
+    // Reverse: config → manifest
+    loadTemplate(tmpl.manifest, tmpl.roles);
+    const config = useConfigStore.getState();
+    const roleModels = new Map(Object.entries(config.roleModels));
+    const manifest = canvasToManifest(
+      config.team,
+      config.roles,
+      config.channels,
+      config.subscriptions,
+      config.emissions,
+      config.peerRoutes,
+      config.spawnRules,
+      config.topologyRoot,
+      config.topologyCompanions,
+      roleModels,
+    );
+
+    expect(manifest.name).toBe(tmpl.manifest.name);
+    expect(manifest.roles.length).toBe(tmpl.manifest.roles.length);
+    expect(manifest.topology.root.role).toBe(tmpl.manifest.topology.root.role);
+  });
+
+  it('rolesToDefinitions converts config roles to YAML-ready format', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    const config = useConfigStore.getState();
+    const defs = rolesToDefinitions(config.roles);
+
+    expect(defs.size).toBe(12);
+
+    const orchestrator = defs.get('orchestrator');
+    expect(orchestrator).toBeDefined();
+    expect(orchestrator?.name).toBe('orchestrator');
+  });
+
+  it('export omits empty emission and subscription arrays', () => {
+    resetStores();
+    useConfigStore.getState().setTeam({ name: 'minimal' });
+    useConfigStore.getState().setRole('root', {
+      name: 'root',
+      displayName: 'Root',
+      description: '',
+      capabilities: [],
+    });
+    useConfigStore.getState().setTopologyRoot('root');
+    // Explicitly set empty emissions
+    useConfigStore.getState().setEmissions('root', []);
+
+    const files = compileToYaml();
+    const manifest = yaml.load(files.find(f => f.path === 'team.yaml')!.content) as Record<string, unknown>;
+
+    // Communication section should not contain empty emissions
+    const comm = manifest.communication as Record<string, unknown> | undefined;
+    if (comm?.emissions) {
+      const emissions = comm.emissions as Record<string, string[]>;
+      for (const val of Object.values(emissions)) {
+        expect(val.length).toBeGreaterThan(0);
+      }
+    }
+  });
+});

package/references/openteams/editor/tests/e2e-template-load.test.ts

@@ -0,0 +1,204 @@
+/**
+ * E2E: Template loading flow
+ * Tests that loading a bundled template correctly populates all stores
+ * and produces the expected canvas state.
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { useCanvasStore } from '../src/stores/canvas-store';
+import { useConfigStore } from '../src/stores/config-store';
+import { useHistoryStore } from '../src/stores/history-store';
+import { useValidationStore } from '../src/stores/validation-store';
+import { BUNDLED_TEMPLATES } from '../src/lib/bundled-templates';
+import { loadTemplate } from '../src/lib/load-template';
+
+function resetStores() {
+  useCanvasStore.getState().clear();
+  useConfigStore.getState().clear();
+  useHistoryStore.getState().clear();
+  useValidationStore.getState().clear();
+}
+
+describe('E2E: Template loading flow', () => {
+  beforeEach(resetStores);
+
+  it('loads gsd template with correct role count', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    const config = useConfigStore.getState();
+    expect(config.roles.size).toBe(12);
+    expect(config.team.name).toBe('gsd');
+  });
+
+  it('creates canvas nodes for each role and channel', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    const canvas = useCanvasStore.getState();
+    const roleNodes = canvas.nodes.filter(n => n.data.kind === 'role');
+    const channelNodes = canvas.nodes.filter(n => n.data.kind === 'channel');
+
+    expect(roleNodes.length).toBe(12);
+    expect(channelNodes.length).toBe(4);
+  });
+
+  it('sets topology root and companions correctly', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    const config = useConfigStore.getState();
+    expect(config.topologyRoot).toBe('orchestrator');
+    expect(config.topologyCompanions).toContain('roadmapper');
+    expect(config.topologyCompanions).toContain('verifier');
+  });
+
+  it('creates peer route edges from routing config', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    const canvas = useCanvasStore.getState();
+    const peerEdges = canvas.edges.filter(e => e.data?.kind === 'peer-route');
+    const config = useConfigStore.getState();
+
+    expect(peerEdges.length).toBe(config.peerRoutes.length);
+  });
+
+  it('creates signal flow edges for emissions and subscriptions', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    const canvas = useCanvasStore.getState();
+    const signalEdges = canvas.edges.filter(e => e.data?.kind === 'signal-flow');
+    const emissionEdges = signalEdges.filter(e => (e.data as any).direction === 'emission');
+    const subEdges = signalEdges.filter(e => (e.data as any).direction === 'subscription');
+
+    // Should have both emission and subscription edges
+    expect(emissionEdges.length).toBeGreaterThan(0);
+    expect(subEdges.length).toBeGreaterThan(0);
+  });
+
+  it('creates spawn edges from spawn_rules', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    const canvas = useCanvasStore.getState();
+    const spawnEdges = canvas.edges.filter(e => e.data?.kind === 'spawn');
+    const config = useConfigStore.getState();
+
+    // orchestrator can spawn 11 roles
+    const orchestratorSpawns = config.spawnRules['orchestrator'] || [];
+    expect(orchestratorSpawns.length).toBe(11);
+
+    // Spawn edges should match total spawn rules
+    const totalSpawnRules = Object.values(config.spawnRules)
+      .reduce((sum, targets) => sum + targets.length, 0);
+    expect(spawnEdges.length).toBe(totalSpawnRules);
+  });
+
+  it('sets correct topology position on role nodes', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    const canvas = useCanvasStore.getState();
+
+    const orchestratorNode = canvas.nodes.find(n => n.id === 'role-orchestrator');
+    expect(orchestratorNode?.data.topologyPosition).toBe('root');
+
+    const roadmapperNode = canvas.nodes.find(n => n.id === 'role-roadmapper');
+    expect(roadmapperNode?.data.topologyPosition).toBe('companion');
+
+    const executorNode = canvas.nodes.find(n => n.id === 'role-executor');
+    expect(executorNode?.data.topologyPosition).toBe('spawned');
+  });
+
+  it('populates channels in config store', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    const config = useConfigStore.getState();
+    const channelNames = Object.keys(config.channels);
+
+    expect(channelNames).toContain('project_lifecycle');
+    expect(channelNames).toContain('planning_events');
+    expect(channelNames).toContain('execution_events');
+    expect(channelNames).toContain('verification_events');
+
+    // Check signals exist in channels
+    expect(config.channels.project_lifecycle.signals).toContain('PROJECT_INITIALIZED');
+    expect(config.channels.execution_events.signals).toContain('WAVE_STARTED');
+  });
+
+  it('resets history on template load', () => {
+    // Load once
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    // Should have exactly one snapshot (the initial push)
+    const history = useHistoryStore.getState();
+    expect(history.undoStack.length).toBe(1);
+    expect(history.redoStack.length).toBe(0);
+  });
+
+  it('loads BMAD template with different structure', () => {
+    const tmpl = BUNDLED_TEMPLATES['bmad-method'];
+    if (!tmpl) return; // Skip if not available
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    const config = useConfigStore.getState();
+    expect(config.team.name).toBe('bmad-method');
+    expect(config.roles.size).toBeGreaterThan(0);
+  });
+
+  it('switching templates replaces all state', () => {
+    const gsd = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(gsd.manifest, gsd.roles);
+
+    const gsdRoleCount = useConfigStore.getState().roles.size;
+
+    // Load a different template
+    const bmad = BUNDLED_TEMPLATES['bmad-method'];
+    if (!bmad) return;
+    loadTemplate(bmad.manifest, bmad.roles);
+
+    const bmadRoleCount = useConfigStore.getState().roles.size;
+    expect(bmadRoleCount).not.toBe(gsdRoleCount);
+    expect(useConfigStore.getState().team.name).toBe('bmad-method');
+  });
+
+  it('populates emission and subscription mappings', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    const config = useConfigStore.getState();
+
+    // Emissions should have at least one role
+    const emittingRoles = Object.keys(config.emissions);
+    expect(emittingRoles.length).toBeGreaterThan(0);
+
+    // Subscriptions should have at least one role
+    const subscribingRoles = Object.keys(config.subscriptions);
+    expect(subscribingRoles.length).toBeGreaterThan(0);
+  });
+
+  it('extracts extensions from manifest', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    const config = useConfigStore.getState();
+    // GSD has a gsd extension key in the manifest
+    const hasExtensions = Object.keys(config.team.extensions).length > 0;
+    // It may or may not have extensions depending on the bundled template
+    // At minimum the extensions object should exist
+    expect(config.team.extensions).toBeDefined();
+  });
+
+  it('auto-layouts nodes with non-zero positions', () => {
+    const tmpl = BUNDLED_TEMPLATES['gsd'];
+    loadTemplate(tmpl.manifest, tmpl.roles);
+
+    const canvas = useCanvasStore.getState();
+    // At least some nodes should have been positioned by dagre
+    const positioned = canvas.nodes.filter(n => n.position.x !== 0 || n.position.y !== 0);
+    expect(positioned.length).toBeGreaterThan(0);
+  });
+});

package/references/openteams/editor/tests/e2e-ui-store.test.ts

@@ -0,0 +1,126 @@
+/**
+ * E2E: UI store and layer toggles
+ * Tests the UI state management, panel visibility,
+ * and layer toggling behavior.
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { useUIStore } from '../src/stores/ui-store';
+
+function resetUI() {
+  // Reset to defaults by toggling back if needed
+  const state = useUIStore.getState();
+  if (!state.sidebarOpen) state.toggleSidebar();
+  if (!state.inspectorOpen) state.toggleInspector();
+  if (state.importModalOpen) state.setImportModalOpen(false);
+  if (state.exportModalOpen) state.setExportModalOpen(false);
+  // Reset layers to defaults
+  if (!state.layers.peerRoutes) state.toggleLayer('peerRoutes');
+  if (!state.layers.channels) state.toggleLayer('channels');
+  if (state.layers.spawnRules) state.toggleLayer('spawnRules');
+  if (state.layers.inheritance) state.toggleLayer('inheritance');
+}
+
+describe('E2E: UI store and layers', () => {
+  beforeEach(resetUI);
+
+  describe('Panel visibility', () => {
+    it('sidebar starts open', () => {
+      expect(useUIStore.getState().sidebarOpen).toBe(true);
+    });
+
+    it('toggle sidebar hides and shows it', () => {
+      useUIStore.getState().toggleSidebar();
+      expect(useUIStore.getState().sidebarOpen).toBe(false);
+
+      useUIStore.getState().toggleSidebar();
+      expect(useUIStore.getState().sidebarOpen).toBe(true);
+    });
+
+    it('inspector starts open', () => {
+      expect(useUIStore.getState().inspectorOpen).toBe(true);
+    });
+
+    it('toggle inspector hides and shows it', () => {
+      useUIStore.getState().toggleInspector();
+      expect(useUIStore.getState().inspectorOpen).toBe(false);
+
+      useUIStore.getState().toggleInspector();
+      expect(useUIStore.getState().inspectorOpen).toBe(true);
+    });
+
+    it('modals start closed', () => {
+      expect(useUIStore.getState().importModalOpen).toBe(false);
+      expect(useUIStore.getState().exportModalOpen).toBe(false);
+    });
+
+    it('opening import modal', () => {
+      useUIStore.getState().setImportModalOpen(true);
+      expect(useUIStore.getState().importModalOpen).toBe(true);
+
+      useUIStore.getState().setImportModalOpen(false);
+      expect(useUIStore.getState().importModalOpen).toBe(false);
+    });
+
+    it('opening export modal', () => {
+      useUIStore.getState().setExportModalOpen(true);
+      expect(useUIStore.getState().exportModalOpen).toBe(true);
+    });
+  });
+
+  describe('Layer toggles', () => {
+    it('peer routes layer starts on', () => {
+      expect(useUIStore.getState().layers.peerRoutes).toBe(true);
+    });
+
+    it('channels layer starts on', () => {
+      expect(useUIStore.getState().layers.channels).toBe(true);
+    });
+
+    it('spawn rules layer starts off', () => {
+      expect(useUIStore.getState().layers.spawnRules).toBe(false);
+    });
+
+    it('inheritance layer starts off', () => {
+      expect(useUIStore.getState().layers.inheritance).toBe(false);
+    });
+
+    it('toggling a layer flips its state', () => {
+      useUIStore.getState().toggleLayer('peerRoutes');
+      expect(useUIStore.getState().layers.peerRoutes).toBe(false);
+
+      useUIStore.getState().toggleLayer('peerRoutes');
+      expect(useUIStore.getState().layers.peerRoutes).toBe(true);
+    });
+
+    it('toggling one layer does not affect others', () => {
+      useUIStore.getState().toggleLayer('spawnRules');
+
+      expect(useUIStore.getState().layers.spawnRules).toBe(true);
+      expect(useUIStore.getState().layers.peerRoutes).toBe(true);
+      expect(useUIStore.getState().layers.channels).toBe(true);
+      expect(useUIStore.getState().layers.inheritance).toBe(false);
+    });
+
+    it('all layers can be turned on simultaneously', () => {
+      useUIStore.getState().toggleLayer('spawnRules');
+      useUIStore.getState().toggleLayer('inheritance');
+
+      const layers = useUIStore.getState().layers;
+      expect(layers.peerRoutes).toBe(true);
+      expect(layers.channels).toBe(true);
+      expect(layers.spawnRules).toBe(true);
+      expect(layers.inheritance).toBe(true);
+    });
+
+    it('all layers can be turned off simultaneously', () => {
+      useUIStore.getState().toggleLayer('peerRoutes');
+      useUIStore.getState().toggleLayer('channels');
+
+      const layers = useUIStore.getState().layers;
+      expect(layers.peerRoutes).toBe(false);
+      expect(layers.channels).toBe(false);
+      expect(layers.spawnRules).toBe(false);
+      expect(layers.inheritance).toBe(false);
+    });
+  });
+});