sdlc-agent-4-enterprise-server 1.0.0

package/tests/e2e/check-lod.mjs

@@ -0,0 +1,33 @@
+import { chromium } from 'playwright';
+
+const browser = await chromium.launch();
+const page = await browser.newPage();
+page.on('console', msg => { if(msg.text().includes('[LOD]')) console.log('CONSOLE:', msg.text()); });
+page.on('pageerror', err => console.log('PAGE ERROR:', err.message));
+
+// Login
+await page.goto('http://localhost:48721/admin');
+await page.waitForSelector('.login-box');
+await page.fill('input[placeholder="Username"]', 'admin');
+await page.fill('input[placeholder="Password"]', 'admin');
+await page.click('button:has-text("Login")');
+await page.waitForSelector('.nav-item', {timeout:10000});
+
+// Graph
+await page.locator('.nav-item:has-text("Graph")').click();
+console.log('Navigated to Graph, waiting 30s...');
+await page.waitForTimeout(30000);
+
+const lod = await page.evaluate(() => !!(window).__lodManager);
+console.log('LOD available after 30s:', lod);
+
+if (!lod) {
+  const check = await page.evaluate(() => ({
+    hasLODClass: typeof window.LODManager !== 'undefined',
+    canvasCount: document.querySelectorAll('canvas').length,
+  }));
+  console.log('Debug:', check);
+}
+
+await browser.close();
+process.exit(0);

package/tests/e2e/debug-collapse.mjs

@@ -0,0 +1,79 @@
+import { chromium } from 'playwright';
+
+const browser = await chromium.launch();
+const page = await browser.newPage();
+page.on('console', msg => { if(msg.text().includes('[LOD]')) console.log('CONSOLE:', msg.text()); });
+
+await page.goto('http://localhost:48721/admin');
+await page.waitForSelector('.login-box');
+await page.fill('input[placeholder="Username"]', 'admin');
+await page.fill('input[placeholder="Password"]', 'admin');
+await page.click('button:has-text("Login")');
+await page.waitForSelector('.nav-item', {timeout:10000});
+await page.locator('.nav-item:has-text("Graph")').click();
+await page.waitForFunction(() => !!window.__lodManager, { timeout: 40000 });
+
+console.log('\n=== INITIAL STATE ===');
+let state = await page.evaluate(() => {
+  const lod = window.__lodManager;
+  const clusters = [...lod._clusters.entries()].map(([id,c]) => ({ id, state: c.state, children: c.childNodeIds.length }));
+  return { clusters: clusters.slice(0, 3), total: clusters.length, visible: lod._visibleNodes.size };
+});
+console.log(JSON.stringify(state, null, 2));
+
+// Stop tick, expand first cluster
+console.log('\n=== EXPANDING ===');
+const expandResult = await page.evaluate(() => {
+  const lod = window.__lodManager;
+  if (lod._rafId) { cancelAnimationFrame(lod._rafId); lod._rafId = null; }
+  const cam = lod._graph.camera().position;
+  const [id, cluster] = [...lod._clusters.entries()][0];
+  cam.x = cluster.center.x; cam.y = cluster.center.y; cam.z = cluster.center.z;
+  const ok = lod.expandCluster(id);
+  return { ok, id, state: cluster.state };
+});
+console.log(JSON.stringify(expandResult));
+
+await page.waitForTimeout(600);
+
+const afterExpand = await page.evaluate(() => {
+  const lod = window.__lodManager;
+  const [id, cluster] = [...lod._clusters.entries()][0];
+  return { id, state: cluster.state, visible: lod._visibleNodes.size };
+});
+console.log('After expand wait:', JSON.stringify(afterExpand));
+
+// Move camera far and check
+console.log('\n=== ZOOM OUT + _checkDistances ===');
+const collapseDebug = await page.evaluate(() => {
+  const lod = window.__lodManager;
+  const [id, cluster] = [...lod._clusters.entries()][0];
+  const cam = lod._graph.camera().position;
+  const centroid = lod._getExpandedCentroid(cluster);
+  cam.x = 9999; cam.y = 9999; cam.z = 9999;
+  const dist = lod._distance(cam, centroid);
+  const shouldCollapse = dist > lod._config.collapseThreshold && !cluster.interacting;
+  lod._checkDistances();
+  return { 
+    stateBefore: cluster.state === 'EXPANDED' ? 'WAS_EXPANDED' : cluster.state,
+    stateAfter: cluster.state, 
+    dist: Math.round(dist), 
+    threshold: lod._config.collapseThreshold,
+    shouldCollapse,
+    interacting: cluster.interacting,
+    animating: lod._animation.isAnimating(id),
+  };
+});
+console.log(JSON.stringify(collapseDebug, null, 2));
+
+await page.waitForTimeout(600);
+
+const afterCollapse = await page.evaluate(() => {
+  const lod = window.__lodManager;
+  const [id, cluster] = [...lod._clusters.entries()][0];
+  return { id, finalState: cluster.state, visible: lod._visibleNodes.size };
+});
+console.log('Final state:', JSON.stringify(afterCollapse));
+
+await browser.close();
+process.exit(0);

package/tests/e2e/debug-expand.mjs

@@ -0,0 +1,38 @@
+import { chromium } from 'playwright';
+
+const browser = await chromium.launch({ headless: false });
+const page = await browser.newPage();
+page.on('console', msg => { if(msg.text().includes('[LOD]')) console.log(msg.text()); });
+
+await page.goto('http://localhost:48721/admin');
+await page.waitForSelector('.login-box');
+await page.fill('input[placeholder="Username"]', 'admin');
+await page.fill('input[placeholder="Password"]', 'admin');
+await page.click('button:has-text("Login")');
+await page.waitForSelector('.nav-item', {timeout:10000});
+await page.locator('.nav-item:has-text("Graph")').click();
+await page.waitForFunction(() => !!window.__lodManager, { timeout: 40000 });
+
+// Log camera distance to nearest cluster every 0.5s
+await page.evaluate(() => {
+  const lod = window.__lodManager;
+  const orig = lod._checkDistances.bind(lod);
+  let count = 0;
+  lod._checkDistances = function() {
+    if (count++ % 30 === 0) {
+      const cam = this._graph.camera().position;
+      let nearest = Infinity, nearestId = '';
+      for (const [id, cluster] of this._clusters) {
+        const d = this._distance(cam, cluster.center);
+        if (d < nearest) { nearest = d; nearestId = id; }
+      }
+      const states = [...this._clusters.values()].map(c => c.state[0]).join('');
+      console.log(`[LOD] cam=(${cam.x.toFixed(0)},${cam.y.toFixed(0)},${cam.z.toFixed(0)}) nearest=${nearestId} dist=${nearest.toFixed(0)} expandThr=${this._config.expandThreshold} states=${states}`);
+    }
+    orig.call(this);
+  };
+});
+
+console.log('\nZoom in toward nodes in the browser window...');
+await page.waitForTimeout(60000);
+await browser.close();

package/tests/e2e/debug-lod.mjs

@@ -0,0 +1,41 @@
+import { chromium } from 'playwright';
+
+const browser = await chromium.launch();
+const page = await browser.newPage();
+page.on('console', msg => console.log('CONSOLE:', msg.text()));
+page.on('pageerror', err => console.log('PAGE ERROR:', err.message));
+
+await page.goto('http://localhost:48721/admin');
+await page.waitForSelector('.login-box');
+await page.fill('input[placeholder="Username"]', 'admin');
+await page.fill('input[placeholder="Password"]', 'admin');
+await page.click('button:has-text("Login")');
+await page.waitForSelector('.nav-item', {timeout:10000});
+await page.locator('.nav-item:has-text("Graph")').click();
+
+console.log('Waiting 15s for LOD init...');
+await page.waitForTimeout(15000);
+
+const debug = await page.evaluate(() => {
+  const lod = window.__lodManager;
+  if (!lod) return { lodExists: false, LODClass: typeof window.LODManager };
+  const graphData = lod._graph.graphData();
+  const first = graphData.nodes[0];
+  return {
+    lodExists: true,
+    initialized: lod._initialized,
+    clusterCount: lod._clusters.size,
+    visibleNodes: lod._visibleNodes.size,
+    graphNodes: graphData.nodes.length,
+    graphLinks: graphData.links.length,
+    firstNodeId: first?.id,
+    firstNodeX: first?.x,
+    firstNodeY: first?.y,
+    firstNodeZ: first?.z,
+    firstNodeIsSuper: first?.__isSuper,
+  };
+});
+
+console.log('LOD Debug:', JSON.stringify(debug, null, 2));
+await browser.close();
+process.exit(0);

package/tests/e2e/debug-realtime.mjs

@@ -0,0 +1,39 @@
+import { chromium } from 'playwright';
+
+const browser = await chromium.launch({ headless: false });
+const page = await browser.newPage();
+page.on('console', msg => { if(msg.text().includes('[LOD]')) console.log(msg.text()); });
+
+await page.goto('http://localhost:48721/admin');
+await page.waitForSelector('.login-box');
+await page.fill('input[placeholder="Username"]', 'admin');
+await page.fill('input[placeholder="Password"]', 'admin');
+await page.click('button:has-text("Login")');
+await page.waitForSelector('.nav-item', {timeout:10000});
+await page.locator('.nav-item:has-text("Graph")').click();
+await page.waitForFunction(() => !!window.__lodManager, { timeout: 40000 });
+
+// Add debug logging to _checkDistances
+await page.evaluate(() => {
+  const lod = window.__lodManager;
+  const orig = lod._checkDistances.bind(lod);
+  let logCount = 0;
+  lod._checkDistances = function() {
+    const cam = this._graph.camera().position;
+    if (logCount++ % 60 === 0) {
+      const expanded = [...this._clusters.values()].filter(c => c.state === 'EXPANDED');
+      if (expanded.length > 0) {
+        for (const c of expanded) {
+          const centroid = this._getExpandedCentroid(c);
+          const dist = this._distance(cam, centroid);
+          console.log(`[LOD] TICK cam=(${cam.x.toFixed(0)},${cam.y.toFixed(0)},${cam.z.toFixed(0)}) cluster=${c.id} dist=${dist.toFixed(0)} threshold=${this._config.collapseThreshold}`);
+        }
+      }
+    }
+    orig.call(this);
+  };
+});
+
+console.log('\nLOD debug active. Interact with graph...');
+await page.waitForTimeout(120000);
+await browser.close();

package/tests/e2e/lod-collapse.e2e.test.ts

@@ -0,0 +1,163 @@
+/**
+ * E2E Tests — KSA-291: LOD Collapse on Zoom Out
+ * Tests real LODManager with real data from server (72k KB entries → 500 graph nodes → LOD clusters).
+ * 
+ * Run: npx playwright test lod-collapse.e2e.test.ts
+ */
+
+import { test, expect, type Page } from '@playwright/test';
+
+const BASE_URL = 'http://localhost:48721';
+const ADMIN_URL = `${BASE_URL}/admin`;
+
+test.setTimeout(60000);
+
+async function loginAndInitLOD(page: Page): Promise<void> {
+  await page.goto(ADMIN_URL);
+  await page.waitForSelector('.login-box', { timeout: 10000 });
+  await page.fill('input[placeholder="Username"]', 'admin');
+  await page.fill('input[placeholder="Password"]', 'admin');
+  await page.click('button:has-text("Login")');
+  await page.waitForSelector('.nav-item', { timeout: 10000 });
+  await page.locator('.nav-item:has-text("Graph")').click();
+  // Wait for LOD to initialize (graph load + 5s delay + clustering)
+  await page.waitForFunction(() => !!(window as any).__lodManager, { timeout: 40000 });
+}
+
+async function getLODState(page: Page) {
+  return page.evaluate(() => {
+    const lod = (window as any).__lodManager;
+    if (!lod || !lod._initialized) return null;
+    const clusters: any[] = [];
+    for (const [id, cluster] of lod._clusters as Map<string, any>) {
+      clusters.push({ id, state: cluster.state, childCount: cluster.childNodeIds?.length || 0 });
+    }
+    return {
+      clusterCount: lod._clusters.size,
+      expandedCount: clusters.filter((c: any) => c.state === 'EXPANDED').length,
+      collapsedCount: clusters.filter((c: any) => c.state === 'COLLAPSED').length,
+      visibleNodeCount: lod._visibleNodes.size,
+      clusters,
+    };
+  });
+}
+
+test.describe('KSA-291: LOD Collapse on Zoom Out', () => {
+  test.beforeEach(async ({ page }) => {
+    await loginAndInitLOD(page);
+  });
+
+  test('E2E-UI-1: Expanded cluster collapses when camera moves far away', async ({ page }) => {
+    const state = await getLODState(page);
+    expect(state).not.toBeNull();
+    expect(state!.clusterCount).toBeGreaterThan(0);
+
+    const target = state!.clusters.find(c => c.state === 'COLLAPSED')!;
+    expect(target).toBeDefined();
+
+    // Expand cluster (stop tick to prevent auto-collapse)
+    const ok = await page.evaluate((cid) => {
+      const lod = (window as any).__lodManager;
+      // Stop auto-tick so _checkDistances doesn't interfere
+      if (lod._rafId) { cancelAnimationFrame(lod._rafId); lod._rafId = null; }
+      return lod.expandCluster(cid);
+    }, target.id);
+    expect(ok).toBe(true);
+    await page.waitForTimeout(500);
+
+    // Verify expanded
+    const s2 = await getLODState(page);
+    expect(s2!.clusters.find(c => c.id === target.id)?.state).toBe('EXPANDED');
+
+    // Move camera far away and trigger collapse
+    await page.evaluate(() => {
+      const lod = (window as any).__lodManager;
+      const cam = lod._graph.camera().position;
+      cam.x = 9999; cam.y = 9999; cam.z = 9999;
+      lod._checkDistances();
+    });
+    await page.waitForTimeout(500);
+
+    // Verify collapse triggered
+    const s3 = await getLODState(page);
+    const final = s3!.clusters.find(c => c.id === target.id);
+    expect(['COLLAPSED', 'COLLAPSING']).toContain(final?.state);
+  });
+
+  test('E2E-UI-2: Budget enforcement prevents exceeding maxVisibleNodes', async ({ page }) => {
+    // Stop tick, then try to expand ALL clusters — budget should block some
+    const result = await page.evaluate(() => {
+      const lod = (window as any).__lodManager;
+      if (lod._rafId) { cancelAnimationFrame(lod._rafId); lod._rafId = null; }
+      const cam = lod._graph.camera().position;
+      let attempted = 0, succeeded = 0;
+      for (const [id, cluster] of lod._clusters) {
+        if (cluster.state !== 'COLLAPSED') continue;
+        attempted++;
+        cam.x = cluster.center.x; cam.y = cluster.center.y; cam.z = cluster.center.z;
+        if (lod.expandCluster(id)) succeeded++;
+      }
+      return { attempted, succeeded, visible: lod._visibleNodes.size };
+    });
+    await page.waitForTimeout(500);
+
+    // Budget enforcement works: either blocks some OR collapses farthest to make room
+    // Key assertion: visible nodes never exceed maxVisibleNodes
+    expect(result.visible).toBeLessThanOrEqual(200);
+  });
+
+  test('E2E-UI-3: All clusters start as COLLAPSED', async ({ page }) => {
+    const state = await getLODState(page);
+    expect(state!.clusterCount).toBeGreaterThan(0);
+    expect(state!.collapsedCount).toBe(state!.clusterCount);
+    expect(state!.expandedCount).toBe(0);
+  });
+
+  test('E2E-UI-4: No stuck clusters after full zoom-out', async ({ page }) => {
+    await page.evaluate(() => {
+      const lod = (window as any).__lodManager;
+      const cam = lod._graph.camera().position;
+      let count = 0;
+      for (const [id, cluster] of lod._clusters) {
+        if (count >= 3) break;
+        if (cluster.state !== 'COLLAPSED') continue;
+        cam.x = cluster.center.x; cam.y = cluster.center.y; cam.z = cluster.center.z;
+        if (lod.expandCluster(id)) count++;
+      }
+    });
+    await page.waitForTimeout(500);
+
+    const s2 = await getLODState(page);
+    expect(s2!.expandedCount).toBeGreaterThanOrEqual(1);
+
+    // Zoom far out
+    await page.evaluate(() => {
+      const lod = (window as any).__lodManager;
+      const cam = lod._graph.camera().position;
+      cam.x = 99999; cam.y = 99999; cam.z = 99999;
+      lod._checkDistances();
+    });
+    await page.waitForTimeout(500);
+
+    const s3 = await getLODState(page);
+    for (const c of s3!.clusters) {
+      expect(['COLLAPSED', 'COLLAPSING']).toContain(c.state);
+    }
+  });
+
+  test('E2E-UI-5: Dynamic centroid uses actual child positions', async ({ page }) => {
+    const result = await page.evaluate(() => {
+      const lod = (window as any).__lodManager;
+      const [, cluster] = [...lod._clusters.entries()][0];
+      cluster.state = 'EXPANDED';
+      const centroid = lod._getExpandedCentroid(cluster);
+      const children = lod._getChildNodes(cluster);
+      if (!children.length) return { pass: true };
+      const ex = children.reduce((s: number, n: any) => s + (n.x || 0), 0) / children.length;
+      const ey = children.reduce((s: number, n: any) => s + (n.y || 0), 0) / children.length;
+      const ez = children.reduce((s: number, n: any) => s + (n.z || 0), 0) / children.length;
+      return { pass: Math.abs(centroid.x - ex) < 0.01 && Math.abs(centroid.y - ey) < 0.01 && Math.abs(centroid.z - ez) < 0.01 };
+    });
+    expect(result.pass).toBe(true);
+  });
+});

package/tests/e2e/mcp-api.e2e.test.ts

@@ -0,0 +1,280 @@
+/**
+ * E2E API Tests — MCP Server (KSA-284: Backend MCP Server)
+ * Tests real HTTP calls to localhost:48721.
+ * Server MUST be running before executing these tests.
+ *
+ * Run: npx vitest run tests/e2e/mcp-api.e2e.test.ts
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+
+const BASE_URL = 'http://localhost:48721';
+
+// ============================================================
+// Setup: Verify server is running
+// ============================================================
+
+beforeAll(async () => {
+  try {
+    const res = await fetch(`${BASE_URL}/health`, { signal: AbortSignal.timeout(5000) });
+    if (!res.ok && res.status !== 503) throw new Error(`Health check returned ${res.status}`);
+  } catch (err) {
+    throw new Error(
+      `Server is not running at ${BASE_URL}. Start it with "npm run dev" before running E2E tests.\n` +
+        `Original error: ${err}`,
+    );
+  }
+});
+
+// ============================================================
+// 1. Health Endpoint
+// ============================================================
+
+describe('E2E MCP — Health', () => {
+  it('GET /health returns 200 with modules status', async () => {
+    const res = await fetch(`${BASE_URL}/health`);
+    expect(res.status).toBe(200);
+    const data = await res.json();
+    expect(data.status).toBe('healthy');
+    expect(data.version).toBeDefined();
+    expect(typeof data.uptime).toBe('number');
+    expect(typeof data.tools_loaded).toBe('number');
+    expect(data.tools_loaded).toBeGreaterThan(0);
+    expect(data.modules).toBeDefined();
+    expect(typeof data.modules).toBe('object');
+  });
+
+  it('GET /health modules all report ready', async () => {
+    const res = await fetch(`${BASE_URL}/health`);
+    const data = await res.json();
+    const modules = data.modules as Record<string, string>;
+    const allReady = Object.values(modules).every(s => s === 'ready');
+    expect(allReady).toBe(true);
+  });
+});
+
+// ============================================================
+// 2. Tools List
+// ============================================================
+
+describe('E2E MCP — Tools List', () => {
+  it('GET /mcp/tools/list returns 200 with tool array', async () => {
+    const res = await fetch(`${BASE_URL}/mcp/tools/list`);
+    expect(res.status).toBe(200);
+    const data = await res.json();
+    expect(data.tools).toBeInstanceOf(Array);
+    expect(data.tools.length).toBeGreaterThan(10);
+  });
+
+  it('each tool has required fields', async () => {
+    const res = await fetch(`${BASE_URL}/mcp/tools/list`);
+    const data = await res.json();
+    for (const tool of data.tools.slice(0, 10)) {
+      expect(tool.name).toBeDefined();
+      expect(typeof tool.name).toBe('string');
+      expect(tool.name.length).toBeGreaterThan(0);
+      expect(tool.description).toBeDefined();
+      expect(tool.inputSchema).toBeDefined();
+    }
+  });
+
+  it('includes core memory tools', async () => {
+    const res = await fetch(`${BASE_URL}/mcp/tools/list`);
+    const data = await res.json();
+    const names = data.tools.map((t: any) => t.name);
+    expect(names).toContain('mem_search');
+    expect(names).toContain('mem_ingest');
+    expect(names).toContain('mem_delete');
+  });
+
+  it('includes orchestration tools', async () => {
+    const res = await fetch(`${BASE_URL}/mcp/tools/list`);
+    const data = await res.json();
+    const names = data.tools.map((t: any) => t.name);
+    expect(names).toContain('find_tools');
+    expect(names).toContain('execute_dynamic_tool');
+  });
+});
+
+// ============================================================
+// 3. Tool Call Execution
+// ============================================================
+
+describe('E2E MCP — Tool Call', () => {
+  it('POST /mcp/tools/call executes mem_search', async () => {
+    const res = await fetch(`${BASE_URL}/mcp/tools/call`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        tool_name: 'mem_search',
+        arguments: { query: 'code intelligence', limit: 5 },
+      }),
+    });
+    expect(res.status).toBe(200);
+    const data = await res.json();
+    expect(data.content).toBeInstanceOf(Array);
+    expect(data.content.length).toBeGreaterThan(0);
+    expect(data.content[0].type).toBe('text');
+    expect(data.isError).toBe(false);
+  });
+
+  it('POST /mcp/tools/call executes find_tools', async () => {
+    const res = await fetch(`${BASE_URL}/mcp/tools/call`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        tool_name: 'find_tools',
+        arguments: { query: 'memory', threshold: 0.3, top_k: 5 },
+      }),
+    });
+    expect(res.status).toBe(200);
+    const data = await res.json();
+    expect(data.isError).toBe(false);
+    // find_tools should return text with tool matches
+    const text = data.content[0].text;
+    expect(text).toBeDefined();
+  });
+
+  it('POST /mcp/tools/call executes agent_log', async () => {
+    const res = await fetch(`${BASE_URL}/mcp/tools/call`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        tool_name: 'agent_log',
+        arguments: { level: 'info', message: 'E2E test log', agent: 'e2e-test' },
+      }),
+    });
+    expect(res.status).toBe(200);
+    const data = await res.json();
+    expect(data.isError).toBe(false);
+  });
+
+  it('POST /mcp/tools/call executes orchestration_status', async () => {
+    const res = await fetch(`${BASE_URL}/mcp/tools/call`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        tool_name: 'orchestration_status',
+        arguments: {},
+      }),
+    });
+    expect(res.status).toBe(200);
+    const data = await res.json();
+    expect(data.isError).toBe(false);
+  });
+});
+
+// ============================================================
+// 4. Memory Lifecycle — Ingest → Search → Read → Delete
+// ============================================================
+
+describe('E2E MCP — Memory Lifecycle', () => {
+  const testTitle = `e2e-lifecycle-${Date.now()}`;
+  const testContent = 'This is E2E lifecycle test content for MCP memory module';
+
+  it('mem_ingest creates an entry', async () => {
+    const res = await fetch(`${BASE_URL}/mcp/tools/call`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        tool_name: 'mem_ingest',
+        arguments: { title: testTitle, content: testContent, tags: 'e2e,test' },
+      }),
+    });
+    expect(res.status).toBe(200);
+    const data = await res.json();
+    expect(data.isError).toBe(false);
+  });
+
+  it('mem_search finds the ingested entry', async () => {
+    const res = await fetch(`${BASE_URL}/mcp/tools/call`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        tool_name: 'mem_search',
+        arguments: { query: testTitle, limit: 10 },
+      }),
+    });
+    expect(res.status).toBe(200);
+    const data = await res.json();
+    expect(data.isError).toBe(false);
+    // The search result should contain text output
+    expect(data.content[0].text).toBeDefined();
+  });
+
+  it('mem_delete removes the entry', async () => {
+    const res = await fetch(`${BASE_URL}/mcp/tools/call`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        tool_name: 'mem_delete',
+        arguments: { id: testTitle },
+      }),
+    });
+    expect(res.status).toBe(200);
+    const data = await res.json();
+    expect(data.isError).toBe(false);
+  });
+});
+
+// ============================================================
+// 5. Error Cases
+// ============================================================
+
+describe('E2E MCP — Error Cases', () => {
+  it('unknown tool returns 404 with TOOL_NOT_FOUND', async () => {
+    const res = await fetch(`${BASE_URL}/mcp/tools/call`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        tool_name: 'totally_fake_tool_that_does_not_exist',
+        arguments: {},
+      }),
+    });
+    expect(res.status).toBe(404);
+    const data = await res.json();
+    expect(data.error.code).toBe('TOOL_NOT_FOUND');
+  });
+
+  it('missing tool_name returns 400', async () => {
+    const res = await fetch(`${BASE_URL}/mcp/tools/call`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ arguments: { query: 'test' } }),
+    });
+    expect(res.status).toBe(400);
+    const data = await res.json();
+    expect(data.error.code).toBe('INVALID_REQUEST');
+  });
+
+  it('invalid JSON returns 400', async () => {
+    const res = await fetch(`${BASE_URL}/mcp/tools/call`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: '{"broken json',
+    });
+    expect(res.status).toBe(400);
+    const data = await res.json();
+    expect(data.error.code).toBe('INVALID_REQUEST');
+  });
+
+  it('empty body returns 400', async () => {
+    const res = await fetch(`${BASE_URL}/mcp/tools/call`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: '',
+    });
+    expect(res.status).toBe(400);
+  });
+
+  it('empty tool_name string returns 400', async () => {
+    const res = await fetch(`${BASE_URL}/mcp/tools/call`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ tool_name: '', arguments: {} }),
+    });
+    expect(res.status).toBe(400);
+    const data = await res.json();
+    expect(data.error.code).toBe('INVALID_REQUEST');
+  });
+});