amalgm 0.1.72 → 0.1.73

package/runtime/scripts/amalgm-mcp/services/control-plane.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const { PORT, STORAGE_DIR } = require('../config');
+const { hasSupabase } = require('../lib/supabase');
+const { createControlPlaneServer } = require('../server/control-plane-service');
+const { startHttpServer } = require('../server/service-lifecycle');
+
+const port = parseInt(process.env.AMALGM_CONTROL_PLANE_PORT || String(PORT), 10);
+
+startHttpServer(createControlPlaneServer(), {
+  port,
+  serviceName: 'AmalgmControlPlane',
+  onListening() {
+    console.log(`[AmalgmControlPlane] Storage: ${STORAGE_DIR}`);
+    console.log(
+      `[AmalgmControlPlane] Supabase: ${hasSupabase() ? 'connected' : 'not configured (runs are local-only)'}`,
+    );
+  },
+});

package/runtime/scripts/amalgm-mcp/services/mcp-adapter.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const { PORT } = require('../config');
+const { createMcpHttpServer } = require('../server/mcp-http-service');
+const { startHttpServer } = require('../server/service-lifecycle');
+
+const port = parseInt(process.env.AMALGM_MCP_ADAPTER_PORT || String(PORT), 10);
+
+startHttpServer(createMcpHttpServer(), {
+  port,
+  serviceName: 'AmalgmMCPAdapter',
+});

package/runtime/scripts/amalgm-mcp/services/runtime-worker.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const {
+  startRuntimeWorker,
+  stopRuntimeWorker,
+} = require('../runtime-worker');
+
+console.log('[AmalgmRuntimeWorker] Starting...');
+startRuntimeWorker();
+
+function shutdown() {
+  console.log('[AmalgmRuntimeWorker] Shutting down...');
+  stopRuntimeWorker();
+  process.exit(0);
+}
+
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);

package/runtime/scripts/amalgm-mcp/slack/inbound.js

@@ -39,6 +39,24 @@ function asString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
 }
 
+function normalizeStringList(values) {
+  if (!Array.isArray(values)) return [];
+  return [...new Set(values
+    .filter((value) => typeof value === 'string')
+    .map((value) => value.trim())
+    .filter(Boolean))];
+}
+
+function sessionToolConfig(metadata) {
+  const tools = metadata?.tools && typeof metadata.tools === 'object' && !Array.isArray(metadata.tools)
+    ? metadata.tools
+    : {};
+  return {
+    mode: tools.mode === 'selected' ? 'selected' : 'all',
+    toolIds: normalizeStringList(tools.selectedToolIds),
+  };
+}
+
 function isDefaultSessionTitle(title) {
   return ['', 'New Chat', 'New session', 'New code session'].includes(String(title || '').trim());
 }
@@ -113,6 +131,7 @@ async function handleSlackInbound(body, sendJson) {
   const defaultAuthMethod = asString(metadata.authMethod) || resolveDefaultAuthMethod(baseHarnessId);
   const cwd = asString(metadata.cwd) || DEFAULT_CWD;
   const computerId = asString(metadata.computerId);
+  const toolConfig = sessionToolConfig(metadata);
   const slackSystemPrompt = [
     asString(metadata.systemPrompt),
     'You are replying in Slack. Keep responses clear, direct, and Slack-friendly. Use concise Markdown/mrkdwn when helpful.',
@@ -129,6 +148,8 @@ async function handleSlackInbound(body, sendJson) {
     },
     tools: {
       mcpAppIds: Array.isArray(metadata.mcpAppIds) ? metadata.mcpAppIds : [],
+      mode: toolConfig.mode,
+      toolIds: toolConfig.toolIds,
     },
     execution: {
       cwd,

package/runtime/scripts/amalgm-mcp/state/snapshot.js

@@ -38,13 +38,13 @@ function readResource(resource, cache) {
     case 'apps':
       return require('../apps/store').loadApps().apps;
     case 'toolbox':
-      cache.toolbox ||= require('../toolbox/store').readToolbox();
+      cache.toolbox ||= require('../toolbox/service').defaultToolboxService.readCatalog();
       return cache.toolbox;
     case 'tools':
-      cache.toolbox ||= require('../toolbox/store').readToolbox();
+      cache.toolbox ||= require('../toolbox/service').defaultToolboxService.readCatalog();
       return cache.toolbox.tools;
     case 'tool_actions':
-      cache.toolbox ||= require('../toolbox/store').readToolbox();
+      cache.toolbox ||= require('../toolbox/service').defaultToolboxService.readCatalog();
       return cache.toolbox.toolActions;
     case 'hooks':
       return require('../agents/hooks').collectNativeHooks();

package/runtime/scripts/amalgm-mcp/tests/agents-source-of-truth.test.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-agents-source-test-'));
+process.env.AMALGM_DIR = path.join(tempRoot, '.amalgm');
+
+const { closeLocalDb } = require('../state/db');
+const { writeUserPreferences } = require('../lib/prefs');
+const {
+  createAgent,
+  getAllAgentsWithBuiltins,
+  resolveAgent,
+  updateAgent,
+} = require('../agents/store');
+
+test.after(() => {
+  closeLocalDb();
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+test('default agent rows backfill prefs once then remain authoritative', () => {
+  writeUserPreferences({
+    usage: { codex: 'provider_auth' },
+    recent_prefs: { codex: 'openai/gpt-5.5' },
+    model_settings: {
+      'openai/gpt-5.5': { effort: 'low', fastMode: true },
+    },
+    last_used: {
+      harness: 'codex',
+      model: 'openai/gpt-5.5',
+      cwd: tempRoot,
+    },
+  });
+
+  const seededCodex = getAllAgentsWithBuiltins().find((agent) => agent.id === 'codex');
+  assert.equal(seededCodex.authMethod, 'provider_auth');
+  assert.deepEqual(seededCodex.modelSettings, { effort: 'low', fastMode: true });
+
+  updateAgent('codex', {
+    authMethod: 'amalgm',
+    modelSettings: { effort: 'high' },
+  });
+  writeUserPreferences({
+    usage: { codex: 'provider_auth' },
+    recent_prefs: { codex: 'openai/gpt-5.5' },
+    model_settings: {
+      'openai/gpt-5.5': { effort: 'low', fastMode: true },
+    },
+    last_used: {
+      harness: 'codex',
+      model: 'openai/gpt-5.5',
+      cwd: tempRoot,
+    },
+  });
+
+  const preservedCodex = resolveAgent('codex');
+  assert.equal(preservedCodex.authMethod, 'amalgm');
+  assert.deepEqual(preservedCodex.modelSettings, { effort: 'high' });
+});
+
+test('custom agent auth and model settings survive normalization', () => {
+  const agent = createAgent({
+    name: 'Provider Codex',
+    baseHarnessId: 'codex',
+    baseModelId: 'openai/gpt-5.5',
+    authMethod: 'provider_auth',
+    modelSettings: { effort: 'medium', fastMode: true },
+    tools: { mode: 'selected', selectedToolIds: ['tool.search'] },
+  });
+
+  assert.equal(agent.authMethod, 'provider_auth');
+  assert.deepEqual(agent.modelSettings, { effort: 'medium', fastMode: true });
+  assert.deepEqual(agent.tools, {
+    mode: 'selected',
+    selectedToolIds: ['tool.search'],
+  });
+});

package/runtime/scripts/amalgm-mcp/tests/automations-store-runner.test.js

@@ -158,14 +158,14 @@ test('workflow compiler accepts compact tool and agent helpers', () => {
   trigger: event("github.push"),
   cells: [
     code("greet", async () => ({ message: "hello" })),
-    tool("notify", "amalgm.notify_user", ({ cells }) => ({ message: cells.greet.output.message })),
+    tool("notify", "amalgm.notifications.notify_user", ({ cells }) => ({ message: cells.greet.output.message })),
     agent("ask_codex", "Codex", { prompt: "Review this", run_in_background: true })
   ]
 })`);
 
-  assert.equal(ir.cells[1].toolId, 'amalgm');
+  assert.equal(ir.cells[1].toolId, 'amalgm.notifications');
   assert.equal(ir.cells[1].actionName, 'notify_user');
-  assert.equal(ir.cells[2].toolId, 'amalgm');
+  assert.equal(ir.cells[2].toolId, 'amalgm.agents');
   assert.equal(ir.cells[2].actionName, 'talk_to_agent');
   assert.equal(ir.cells[2].args.agent, 'Codex');
 });
@@ -187,7 +187,7 @@ test('automation validator catches dry-run cell reference failures without persi
   trigger: event("test.validate"),
   cells: [
     code("greet", async () => ({ message: "hello" })),
-    tool("notify", "amalgm.notify_user", ({ cells }) => ({ message: cells.greet.output.message }))
+    tool("notify", "amalgm.notifications.notify_user", ({ cells }) => ({ message: cells.greet.output.message }))
   ]
 })`);
 
@@ -198,7 +198,7 @@ test('automation validator catches dry-run cell reference failures without persi
   trigger: event("test.validate"),
   cells: [
     code("greet", async () => ({ message: "hello" })),
-    tool("notify", "amalgm.notify_user", ({ cells }) => ({ message: cells.missing.output.message }))
+    tool("notify", "amalgm.notifications.notify_user", ({ cells }) => ({ message: cells.missing.output.message }))
   ]
 })`);
 

package/runtime/scripts/amalgm-mcp/tests/core-tools.test.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+
+const { CORE_TOOL_GROUPS, CORE_TOOLS } = require('../server/core-tools');
+
+test('core tools are grouped into first-party toolbox-style defaults', () => {
+  assert.deepEqual(CORE_TOOL_GROUPS.map((group) => group.id), [
+    'amalgm.automations',
+    'amalgm.notifications',
+    'amalgm.agents',
+    'amalgm.apps',
+    'amalgm.browser',
+  ]);
+  assert.equal(CORE_TOOL_GROUPS.every((group) => group.origin === 'system'), true);
+  assert.equal(CORE_TOOL_GROUPS.every((group) => group.owner === 'amalgm'), true);
+});
+
+test('core tool grouping preserves handler definitions for MCP surface wrapping', () => {
+  const groupedTools = CORE_TOOL_GROUPS.flatMap((group) => group.tools);
+
+  assert.equal(CORE_TOOLS.length, groupedTools.length);
+  assert.deepEqual(CORE_TOOLS.map((tool) => tool.name), groupedTools.map((tool) => tool.name));
+  assert.equal(CORE_TOOLS.some((tool) => tool.name === 'browser_navigate'), true);
+  assert.equal(CORE_TOOLS.some((tool) => tool.name === 'notify_user'), true);
+});
+
+test('core tool actions carry stable toolbox ids', () => {
+  const browserNavigate = CORE_TOOLS.find((tool) => tool.name === 'browser_navigate');
+  const notifyUser = CORE_TOOLS.find((tool) => tool.name === 'notify_user');
+
+  assert.equal(browserNavigate.toolboxToolId, 'amalgm.browser');
+  assert.equal(browserNavigate.toolboxActionId, 'amalgm.browser.browser_navigate');
+  assert.equal(notifyUser.toolboxToolId, 'amalgm.notifications');
+  assert.equal(notifyUser.toolboxActionId, 'amalgm.notifications.notify_user');
+});

package/runtime/scripts/amalgm-mcp/tests/mcp-surface.test.js

@@ -0,0 +1,158 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+
+const { textResult } = require('../lib/tool-result');
+const {
+  createToolboxMcpSurface,
+  mcpNameForStaticTool,
+  toolDescriptor,
+} = require('../toolbox/mcp-surface');
+
+function staticTools() {
+  return [
+    {
+      name: 'static_echo',
+      description: 'Echo through a static tool.',
+      inputSchema: { type: 'object', properties: { value: { type: 'string' } } },
+      toolboxToolId: 'amalgm.test',
+      toolboxActionId: 'amalgm.test.static_echo',
+      async handler(args, context) {
+        return textResult(JSON.stringify({ args, callerSessionId: context.callerSessionId }));
+      },
+    },
+    {
+      name: 'static_fail',
+      description: 'Throw from a static tool.',
+      inputSchema: { type: 'object', properties: {} },
+      toolboxToolId: 'amalgm.failures',
+      toolboxActionId: 'amalgm.failures.static_fail',
+      async handler() {
+        throw new Error('planned failure');
+      },
+    },
+  ];
+}
+
+test('toolDescriptor exposes only MCP descriptor fields', () => {
+  assert.deepEqual(toolDescriptor({
+    name: 'x',
+    description: 'X',
+    inputSchema: { type: 'object', properties: {} },
+    handler: async () => textResult('ignored'),
+    privateField: true,
+  }), {
+    name: 'x',
+    description: 'X',
+    inputSchema: { type: 'object', properties: {} },
+  });
+});
+
+test('mcpNameForStaticTool uses Toolbox action ids for first-party tools', () => {
+  assert.equal(mcpNameForStaticTool(staticTools()[0]), 'toolbox__amalgm_test_static_echo');
+  assert.equal(mcpNameForStaticTool({ name: 'toolbox_list' }), 'toolbox_list');
+});
+
+test('MCP surface lists static tools plus dynamic toolbox tools', async () => {
+  const calls = [];
+  const surface = createToolboxMcpSurface({
+    staticTools: staticTools(),
+    async listDynamicTools(context) {
+      calls.push(context);
+      return [{
+        name: 'toolbox__dynamic_run',
+        description: 'Run dynamic action.',
+        inputSchema: { type: 'object', properties: { ok: { type: 'boolean' } } },
+      }];
+    },
+  });
+
+  const tools = await surface.listTools({ callerSessionId: 'session-1' });
+
+  assert.deepEqual(calls, [{ callerSessionId: 'session-1' }]);
+  assert.deepEqual(tools.map((tool) => tool.name), [
+    'toolbox__amalgm_test_static_echo',
+    'toolbox__amalgm_failures_static_fail',
+    'toolbox__dynamic_run',
+  ]);
+  assert.equal(tools[0].handler, undefined);
+});
+
+test('MCP surface calls static and dynamic tools', async () => {
+  const dynamicCalls = [];
+  const surface = createToolboxMcpSurface({
+    staticTools: staticTools(),
+    async callDynamicTool(toolName, args, context) {
+      dynamicCalls.push({ toolName, args, context });
+      if (toolName === 'toolbox__dynamic_run') {
+        return textResult(JSON.stringify({ dynamic: true, args }));
+      }
+      return null;
+    },
+  });
+
+  const staticResult = await surface.callTool('toolbox__amalgm_test_static_echo', { value: 'hi' }, { callerSessionId: 'session-2' });
+  const dynamicResult = await surface.callTool('toolbox__dynamic_run', { ok: true }, { callerSessionId: 'session-3' });
+  const missingResult = await surface.callTool('missing_tool', {}, { callerSessionId: 'session-4' });
+
+  assert.deepEqual(JSON.parse(staticResult.content[0].text), {
+    args: { value: 'hi' },
+    callerSessionId: 'session-2',
+  });
+  assert.deepEqual(JSON.parse(dynamicResult.content[0].text), {
+    dynamic: true,
+    args: { ok: true },
+  });
+  assert.deepEqual(dynamicCalls, [
+    {
+      toolName: 'toolbox__dynamic_run',
+      args: { ok: true },
+      context: { callerSessionId: 'session-3' },
+    },
+    {
+      toolName: 'missing_tool',
+      args: {},
+      context: { callerSessionId: 'session-4' },
+    },
+  ]);
+  assert.equal(missingResult.isError, true);
+  assert.equal(missingResult.content[0].text, 'Unknown tool: missing_tool');
+});
+
+test('MCP surface filters static tools in selected-tool mode', async () => {
+  const surface = createToolboxMcpSurface({
+    staticTools: staticTools(),
+    async listDynamicTools() {
+      return [];
+    },
+    async callDynamicTool() {
+      return null;
+    },
+  });
+  const context = {
+    sessionMetadata: {
+      tools: {
+        mode: 'selected',
+        selectedToolIds: ['amalgm.test'],
+      },
+    },
+  };
+
+  const listed = await surface.listTools(context);
+  const selectedResult = await surface.callTool('toolbox__amalgm_test_static_echo', { value: 'ok' }, context);
+  const unselectedResult = await surface.callTool('toolbox__amalgm_failures_static_fail', {}, context);
+
+  assert.deepEqual(listed.map((tool) => tool.name), ['toolbox__amalgm_test_static_echo']);
+  assert.equal(JSON.parse(selectedResult.content[0].text).args.value, 'ok');
+  assert.equal(unselectedResult.isError, true);
+  assert.equal(unselectedResult.content[0].text, 'Unknown tool: toolbox__amalgm_failures_static_fail');
+});
+
+test('MCP surface converts static handler errors into MCP errors', async () => {
+  const surface = createToolboxMcpSurface({ staticTools: staticTools() });
+  const result = await surface.callTool('toolbox__amalgm_failures_static_fail', {}, {});
+
+  assert.equal(result.isError, true);
+  assert.equal(result.content[0].text, 'Error: planned failure');
+});

package/runtime/scripts/amalgm-mcp/tests/server-routing.test.js

@@ -0,0 +1,81 @@
+'use strict';
+
+process.env.AMALGM_RUNTIME_AUTH = 'disabled';
+process.env.AMALGM_DIR = require('node:fs').mkdtempSync(
+  require('node:path').join(require('node:os').tmpdir(), 'amalgm-server-routing-'),
+);
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+
+const { createServer } = require('../server/http');
+const { createLocalServiceRouter } = require('../server/local-service-router');
+const { requestPathname, requestQuery } = require('../server/http-context');
+const { isMcpRequest } = require('../server/mcp-adapter');
+
+function listen(server) {
+  return new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+      server.off('error', reject);
+      resolve(server.address().port);
+    });
+  });
+}
+
+function close(server) {
+  return new Promise((resolve, reject) => {
+    server.close((err) => (err ? reject(err) : resolve()));
+  });
+}
+
+function fakeReq(url, method = 'GET') {
+  return { url, method, headers: {} };
+}
+
+test('HTTP context parses path and query independently', () => {
+  assert.equal(requestPathname(fakeReq('/toolbox/tools?id=amalgm')), '/toolbox/tools');
+  assert.deepEqual(requestQuery(fakeReq('/toolbox/tools?id=amalgm')), { id: 'amalgm' });
+  assert.equal(isMcpRequest('/mcp'), true);
+  assert.equal(isMcpRequest('/mcp/'), true);
+  assert.equal(isMcpRequest('/toolbox'), false);
+});
+
+test('local service router stops at the first handled route group', async () => {
+  const calls = [];
+  const router = createLocalServiceRouter([
+    async () => {
+      calls.push('first');
+      return false;
+    },
+    async () => {
+      calls.push('second');
+      return true;
+    },
+    async () => {
+      calls.push('third');
+      return true;
+    },
+  ]);
+
+  assert.equal(await router.handle({}), true);
+  assert.deepEqual(calls, ['first', 'second']);
+});
+
+test('server dispatches non-DB local routes and 404 routes', async () => {
+  const server = createServer();
+  const port = await listen(server);
+  const baseUrl = `http://127.0.0.1:${port}`;
+
+  try {
+    const events = await fetch(`${baseUrl}/events`);
+    assert.equal(events.status, 200);
+    assert.deepEqual(await events.json(), { events: [] });
+
+    const missing = await fetch(`${baseUrl}/definitely-missing`);
+    assert.equal(missing.status, 404);
+    assert.equal(await missing.text(), 'Not found');
+  } finally {
+    await close(server);
+  }
+});

package/runtime/scripts/amalgm-mcp/tests/server-services.test.js

@@ -0,0 +1,156 @@
+'use strict';
+
+process.env.AMALGM_RUNTIME_AUTH = 'disabled';
+process.env.AMALGM_DIR = require('node:fs').mkdtempSync(
+  require('node:path').join(require('node:os').tmpdir(), 'amalgm-server-services-'),
+);
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+
+const { createRuntimeWorker } = require('../runtime-worker');
+const { createCombinedServer } = require('../server/combined-service');
+const { createControlPlaneServer } = require('../server/control-plane-service');
+const { createMcpHttpServer } = require('../server/mcp-http-service');
+const { startHttpServer } = require('../server/service-lifecycle');
+
+function listen(server) {
+  return new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+      server.off('error', reject);
+      resolve(server.address().port);
+    });
+  });
+}
+
+function close(server) {
+  return new Promise((resolve, reject) => {
+    server.close((err) => (err ? reject(err) : resolve()));
+  });
+}
+
+function controlRoute(calls = []) {
+  return async (ctx) => {
+    calls.push(`control:${ctx.pathname}`);
+    if (ctx.pathname !== '/control') return false;
+    ctx.sendJson(200, { service: 'control-plane' });
+    return true;
+  };
+}
+
+function mcpRoute(calls = []) {
+  return async (ctx) => {
+    calls.push(`mcp:${ctx.pathname}`);
+    if (ctx.pathname !== '/mcp') return false;
+    ctx.sendJson(200, { service: 'mcp-adapter' });
+    return true;
+  };
+}
+
+test('runtime worker lifecycle is idempotent', () => {
+  const calls = [];
+  const worker = createRuntimeWorker({
+    startAutomationScheduler() {
+      calls.push('start');
+    },
+    stopAutomationScheduler() {
+      calls.push('stop');
+    },
+  });
+
+  assert.equal(worker.running, false);
+  assert.equal(worker.start(), true);
+  assert.equal(worker.running, true);
+  assert.equal(worker.start(), false);
+  assert.equal(worker.stop(), true);
+  assert.equal(worker.running, false);
+  assert.equal(worker.stop(), false);
+  assert.deepEqual(calls, ['start', 'stop']);
+});
+
+test('service lifecycle starts HTTP servers without installing shutdown handlers', async () => {
+  const server = createControlPlaneServer({ routeGroups: [controlRoute()] });
+  startHttpServer(server, {
+    port: 0,
+    serviceName: 'TestControlPlane',
+    installShutdown: false,
+  });
+  await new Promise((resolve) => server.once('listening', resolve));
+  const port = server.address().port;
+
+  try {
+    const control = await fetch(`http://127.0.0.1:${port}/control`);
+    assert.equal(control.status, 200);
+    assert.deepEqual(await control.json(), { service: 'control-plane' });
+  } finally {
+    await close(server);
+  }
+});
+
+test('control-plane server handles only local API routes', async () => {
+  const server = createControlPlaneServer({ routeGroups: [controlRoute()] });
+  const port = await listen(server);
+  const baseUrl = `http://127.0.0.1:${port}`;
+
+  try {
+    const control = await fetch(`${baseUrl}/control`);
+    assert.equal(control.status, 200);
+    assert.deepEqual(await control.json(), { service: 'control-plane' });
+
+    const mcp = await fetch(`${baseUrl}/mcp`);
+    assert.equal(mcp.status, 404);
+  } finally {
+    await close(server);
+  }
+});
+
+test('MCP HTTP server handles only MCP routes', async () => {
+  const server = createMcpHttpServer({ mcpRequestHandler: mcpRoute() });
+  const port = await listen(server);
+  const baseUrl = `http://127.0.0.1:${port}`;
+
+  try {
+    const mcp = await fetch(`${baseUrl}/mcp`);
+    assert.equal(mcp.status, 200);
+    assert.deepEqual(await mcp.json(), { service: 'mcp-adapter' });
+
+    const control = await fetch(`${baseUrl}/control`);
+    assert.equal(control.status, 404);
+  } finally {
+    await close(server);
+  }
+});
+
+test('combined server tries MCP before control-plane routes', async () => {
+  const calls = [];
+  const server = createCombinedServer({
+    mcpRequestHandler: mcpRoute(calls),
+    routeGroups: [controlRoute(calls)],
+  });
+  const port = await listen(server);
+  const baseUrl = `http://127.0.0.1:${port}`;
+
+  try {
+    const mcp = await fetch(`${baseUrl}/mcp`);
+    assert.equal(mcp.status, 200);
+    assert.deepEqual(await mcp.json(), { service: 'mcp-adapter' });
+
+    const control = await fetch(`${baseUrl}/control`);
+    assert.equal(control.status, 200);
+    assert.deepEqual(await control.json(), { service: 'control-plane' });
+
+    const missing = await fetch(`${baseUrl}/missing`);
+    assert.equal(missing.status, 404);
+  } finally {
+    await close(server);
+  }
+
+  assert.deepEqual(calls, [
+    'mcp:/mcp',
+    'mcp:/control',
+    'control:/control',
+    'mcp:/missing',
+    'control:/missing',
+  ]);
+});