test: byte-prove workspace routing; refresh stale e2e; merge duplicate coverage

- New effective_features integration suite: a mapping yields the exact tools a
  session sees (resolver -> get_tools_for_grants), and an unbound root resolves
  to zero effective tools.
- feature_set_resolver: two sessions on DIFFERENT roots resolve independently;
  two on the SAME root resolve to the same binding (session-keyed routing,
  distinguished only by session_id for notification).
- Merge the duplicate "unbound root -> Deny" case (kept in the resolver
  decision-table; the events suite keeps the Deny -> WorkspaceBinding flip).
- e2e: rewrite the stale workspaces spec to the current API (feature_set_ids,
  getDefaultSpace, workspace-entry-* cards) + manual-Apply create + duplicate
  validation (TC-WS-007); add a Built-in Servers nav smoke (TC-BS-001).

Signed-off-by: Mohammod Al Amin Ashik <maa.ashik00@gmail.com>

Author: its-mash

tests/e2e/helpers/tauri-api.ts

@@ -96,7 +96,8 @@ export async function listClients(): Promise<Client[]> {
 export interface FeatureSet {
   id: string;
   name: string;
-  feature_set_type: 'default' | 'custom';
+  // 'starter' is the current auto-seeded type; 'default' is the legacy alias.
+  feature_set_type: 'starter' | 'default' | 'custom';
   server_id: string | null;
   is_builtin: boolean;
 }
@@ -262,15 +263,17 @@ export interface WorkspaceBinding {
   id: string;
   workspace_root: string;
   space_id: string;
-  feature_set_id: string;
+  /** A binding can map to one or more FeatureSets (order = render order). */
+  feature_set_ids: string[];
   created_at: string;
   updated_at: string;
 }
 
 export interface WorkspaceBindingInput {
   workspace_root: string;
   space_id: string;
-  feature_set_id: string;
+  /** Non-empty: at least one FeatureSet id. */
+  feature_set_ids: string[];
 }
 
 export async function listWorkspaceBindings(): Promise<WorkspaceBinding[]> {

tests/e2e/specs/builtin-servers.wdio.ts

@@ -0,0 +1,31 @@
+/**
+ * E2E Tests: Built-in Servers page.
+ *
+ * The tab that houses McpMux's own bundled MCP servers. Today it surfaces one
+ * concrete server — "Tool Optimization" (the mcpmux_* self-management tools) —
+ * with a master enable switch, moved here out of Settings.
+ *
+ * Uses data-testid only (ADR-003).
+ */
+
+import { byTestId, safeClick } from '../helpers/selectors';
+
+describe('Built-in Servers - Page shell', () => {
+  it('TC-BS-001: Navigate to Built-in Servers and see Tool Optimization', async () => {
+    const nav = await byTestId('nav-builtin-servers');
+    await safeClick(nav);
+    await browser.pause(1200);
+
+    await browser.saveScreenshot('./tests/e2e/screenshots/bs-01-page.png');
+
+    const src = await browser.getPageSource();
+    expect(src.includes('Built-in Servers')).toBe(true);
+    expect(src.includes('Tool Optimization')).toBe(true);
+
+    // The Tool Optimization server card + its enable switch are present.
+    const card = await byTestId('builtin-server-tool-optimization');
+    expect(await card.isDisplayed()).toBe(true);
+    const toggle = await byTestId('meta-tools-enabled-switch');
+    expect(await toggle.isDisplayed()).toBe(true);
+  });
+});

tests/e2e/specs/workspaces.wdio.ts

@@ -1,9 +1,10 @@
 /**
  * E2E Tests: Workspaces page.
  *
- * A WorkspaceBinding maps a normalized filesystem path to a concrete
- * (space_id, feature_set_id) pair. Roots are globally unique. These specs
- * cover the CRUD path plus the UI shell.
+ * A WorkspaceBinding ("mapping") maps a normalized filesystem path to one or
+ * more FeatureSets within a Space. Roots are globally unique. These specs
+ * cover the CRUD path, the UI card render, the manual-Apply create form, and
+ * duplicate-folder validation.
  *
  * Uses data-testid only (ADR-003).
  */
@@ -12,7 +13,7 @@ import { byTestId, safeClick, TIMEOUT } from '../helpers/selectors';
 import {
   createWorkspaceBinding,
   deleteWorkspaceBinding,
-  getActiveSpace,
+  getDefaultSpace,
   listFeatureSetsBySpace,
   listWorkspaceBindings,
   type WorkspaceBinding,
@@ -25,10 +26,19 @@ function uniqueRoot(): string {
     : `/tmp/mcpmux-e2e-${stamp}`;
 }
 
+/** First auto-seeded ("starter"/legacy "default") FS in a space, else any. */
+async function pickFeatureSet(spaceId: string): Promise<string> {
+  const fsList = await listFeatureSetsBySpace(spaceId);
+  const seed =
+    fsList.find((fs) => fs.feature_set_type === 'starter' || fs.feature_set_type === 'default') ??
+    fsList[0];
+  if (!seed) throw new Error('No FeatureSet in space — cannot set up test');
+  return seed.id;
+}
+
 describe('Workspaces - Page shell', () => {
   before(async () => {
-    // Clean any leftover e2e bindings so the empty-state / populated-state
-    // assertions are deterministic across reruns.
+    // Clean any leftover e2e bindings so the state assertions are deterministic.
     const existing = await listWorkspaceBindings();
     for (const b of existing.filter((x) => x.workspace_root.includes('mcpmux-e2e'))) {
       await deleteWorkspaceBinding(b.id);
@@ -57,29 +67,26 @@ describe('Workspaces - Create, render, delete', () => {
   const root = uniqueRoot();
 
   before(async () => {
-    const active = await getActiveSpace();
-    if (!active) throw new Error('No active space — cannot set up test');
-    spaceId = active.id;
-    const fsList = await listFeatureSetsBySpace(spaceId);
-    const defaultFs = fsList.find((fs) => fs.feature_set_type === 'default');
-    if (!defaultFs) throw new Error('No Default FS in active space');
-    featureSetId = defaultFs.id;
+    const space = await getDefaultSpace();
+    if (!space) throw new Error('No default space — cannot set up test');
+    spaceId = space.id;
+    featureSetId = await pickFeatureSet(spaceId);
   });
 
-  it('TC-WS-002: Create binding pointing at the active space default FS', async () => {
+  it('TC-WS-002: Create mapping pointing at the default space FS', async () => {
     const created: WorkspaceBinding = await createWorkspaceBinding({
       workspace_root: root,
       space_id: spaceId,
-      feature_set_id: featureSetId,
+      feature_set_ids: [featureSetId],
     });
     bindingId = created.id;
 
     expect(created.workspace_root.toLowerCase().endsWith(root.toLowerCase())).toBe(true);
     expect(created.space_id).toBe(spaceId);
-    expect(created.feature_set_id).toBe(featureSetId);
+    expect(created.feature_set_ids).toContain(featureSetId);
   });
 
-  it('TC-WS-003: Binding row renders on the Workspaces page', async () => {
+  it('TC-WS-003: Mapping card renders on the Workspaces page', async () => {
     const nav = await byTestId('nav-workspaces');
     await safeClick(nav);
     await browser.pause(1500);
@@ -94,22 +101,21 @@ describe('Workspaces - Create, render, delete', () => {
     await browser.saveScreenshot('./tests/e2e/screenshots/ws-02-populated.png');
 
     if (bindingId) {
-      const row = await $(`[data-testid="workspace-binding-row-${bindingId}"]`);
-      await row.waitForDisplayed({ timeout: TIMEOUT.short });
-      expect(await row.isDisplayed()).toBe(true);
+      const card = await $(`[data-testid="workspace-entry-${bindingId}"]`);
+      await card.waitForDisplayed({ timeout: TIMEOUT.short });
+      expect(await card.isDisplayed()).toBe(true);
     }
   });
 
-  it('TC-WS-004: Binding row references the target Space + FS by name', async () => {
+  it('TC-WS-004: Card references the target Space by name', async () => {
     const src = await browser.getPageSource();
-    // The row's footer shows "Routes to <FS> in <Space>" — check the Space
-    // name is present. FS is "Default" (builtin) which may also appear in
-    // unrelated copy, so we only assert on the Space name for stability.
-    const active = await getActiveSpace();
-    expect(src.includes(active?.name ?? '__never__')).toBe(true);
+    // The card footer shows "Serves <FS> from <Space>" — check the Space name
+    // is present (FS names may collide with unrelated copy).
+    const space = await getDefaultSpace();
+    expect(src.includes(space?.name ?? '__never__')).toBe(true);
   });
 
-  it('TC-WS-005: Delete binding and row disappears', async () => {
+  it('TC-WS-005: Delete mapping and card disappears', async () => {
     if (!bindingId) throw new Error('bindingId missing — TC-WS-002 must succeed first');
     await deleteWorkspaceBinding(bindingId);
 
@@ -120,8 +126,8 @@ describe('Workspaces - Create, render, delete', () => {
     await safeClick(nav);
     await browser.pause(1500);
 
-    const rows = await $$(`[data-testid="workspace-binding-row-${bindingId}"]`);
-    expect(rows.length).toBe(0);
+    const cards = await $$(`[data-testid="workspace-entry-${bindingId}"]`);
+    expect(cards.length).toBe(0);
     bindingId = null;
   });
 
@@ -139,7 +145,7 @@ describe('Workspaces - Create, render, delete', () => {
 describe('Workspaces - Create form flow (UI)', () => {
   let bindingId: string | null = null;
 
-  it('TC-WS-006: Create binding through the form and see it listed', async () => {
+  it('TC-WS-006: Create mapping through the form and see it listed', async () => {
     const nav = await byTestId('nav-workspaces');
     await safeClick(nav);
     await browser.pause(1000);
@@ -151,27 +157,58 @@ describe('Workspaces - Create form flow (UI)', () => {
     const rootInput = await byTestId('workspace-binding-root-input');
     const root = uniqueRoot();
     await rootInput.setValue(root);
+    // Let the debounced root validation + default FS auto-select settle.
+    await browser.pause(600);
 
-    // `space` and `fs` default to the active space + its Default FS, so we
-    // can submit without touching the pickers.
+    // Space defaults to the default space + its starter FS is auto-selected,
+    // so the explicit Apply ("Create mapping") can be pressed without touching
+    // the pickers.
     const submit = await byTestId('workspace-binding-submit');
+    await submit.waitForEnabled({ timeout: TIMEOUT.short });
     await safeClick(submit);
     await browser.pause(800);
 
-    const created = (await listWorkspaceBindings()).find(
-      (b) => b.workspace_root.toLowerCase().endsWith(root.toLowerCase())
+    const created = (await listWorkspaceBindings()).find((b) =>
+      b.workspace_root.toLowerCase().endsWith(root.toLowerCase())
     );
     expect(created).toBeTruthy();
     if (created) {
       bindingId = created.id;
-      const row = await $(`[data-testid="workspace-binding-row-${created.id}"]`);
-      await row.waitForDisplayed({ timeout: TIMEOUT.short });
-      expect(await row.isDisplayed()).toBe(true);
+      const card = await $(`[data-testid="workspace-entry-${created.id}"]`);
+      await card.waitForDisplayed({ timeout: TIMEOUT.short });
+      expect(await card.isDisplayed()).toBe(true);
     }
 
     await browser.saveScreenshot('./tests/e2e/screenshots/ws-04-created-via-form.png');
   });
 
+  it('TC-WS-007: Mapping an already-mapped folder shows a duplicate error and blocks Apply', async () => {
+    if (!bindingId) throw new Error('bindingId missing — TC-WS-006 must succeed first');
+    const existing = (await listWorkspaceBindings()).find((b) => b.id === bindingId);
+    if (!existing) throw new Error('expected the TC-WS-006 binding to still exist');
+
+    const nav = await byTestId('nav-workspaces');
+    await safeClick(nav);
+    await browser.pause(800);
+
+    const toggle = await byTestId('workspace-binding-create-toggle');
+    await safeClick(toggle);
+    await browser.pause(400);
+
+    const rootInput = await byTestId('workspace-binding-root-input');
+    await rootInput.setValue(existing.workspace_root);
+    await browser.pause(700); // debounced validation + duplicate check
+
+    const dupError = await byTestId('workspace-binding-duplicate-error');
+    await dupError.waitForDisplayed({ timeout: TIMEOUT.short });
+    expect(await dupError.isDisplayed()).toBe(true);
+
+    const submit = await byTestId('workspace-binding-submit');
+    expect(await submit.isEnabled()).toBe(false);
+
+    await browser.saveScreenshot('./tests/e2e/screenshots/ws-05-duplicate.png');
+  });
+
   after(async () => {
     if (bindingId) {
       try {