@letsrunit/mcp-server 0.14.4 → 0.15.0

package/src/index.ts

@@ -2,10 +2,10 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { bootstrapProjectServer } from './bootstrap';
 
-declare const __LETSRUNIT_VERSION__: string;
+declare const __LETSRUNIT_VERSION__: string | undefined;
 
 const version = typeof __LETSRUNIT_VERSION__ === 'string' ? __LETSRUNIT_VERSION__ : 'unknown';
-bootstrapProjectServer();
+const runtimeMode = bootstrapProjectServer();
 
 const { SessionManager } = await import('./sessions');
 const {
@@ -14,6 +14,7 @@ const {
   registerDiff,
   registerListSteps,
   registerListSessions,
+  registerReload,
   registerRun,
   registerScreenshot,
   registerSessionClose,
@@ -29,7 +30,7 @@ const server = new McpServer({
   websiteUrl: 'https://letsrunit.ai',
 });
 
-registerSessionStart(server, sessions);
+registerSessionStart(server, sessions, { runtimeMode });
 registerRun(server, sessions);
 registerSnapshot(server, sessions);
 registerScreenshot(server, sessions);
@@ -37,6 +38,7 @@ registerDebug(server, sessions);
 registerSessionClose(server, sessions);
 registerListSteps(server, sessions);
 registerListSessions(server, sessions);
+registerReload(server, { runtimeMode });
 registerDiff(server, sessions);
 if (process.env.LETSRUNIT_MCP_DIAGNOSTICS === 'enabled') {
   registerDiagnostics(server, sessions);

package/src/tools/diagnostics.ts

@@ -1,7 +1,7 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import type { SessionManager } from '../sessions';
-import { collectSupportDiagnostics } from '../utility/support';
+import { collectDiagnostics } from '../utility/diagnostics';
 import { err, text } from '../utility/response';
 
 export function registerDiagnostics(server: McpServer, sessions: SessionManager): void {
@@ -16,7 +16,7 @@ export function registerDiagnostics(server: McpServer, sessions: SessionManager)
     },
     async (input) => {
       try {
-        const diagnostics = await collectSupportDiagnostics();
+        const diagnostics = await collectDiagnostics();
         const session = sessions.get(input.sessionId);
         const sessionInfo = {
           sessionId: session.id,

package/src/tools/index.ts

@@ -4,6 +4,7 @@ export { registerDiff } from './diff';
 export { registerListSteps } from './list-steps';
 export { registerListSessions } from './list-sessions';
 export { registerRun } from './run';
+export { registerReload } from './reload';
 export { registerScreenshot } from './screenshot';
 export { registerSessionClose } from './session-close';
 export { registerSessionStart } from './session-start';

package/src/tools/reload.ts

@@ -0,0 +1,56 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { McpRuntimeMode } from '../bootstrap';
+import { err, text } from '../utility/response';
+import { reloadSupportFiles } from '../utility/support';
+
+type Options = {
+  runtimeMode: McpRuntimeMode;
+};
+
+async function resetBuiltInStepRegistry(): Promise<void> {
+  const bdd = (await import('@letsrunit/bdd')) as Record<string, unknown>;
+  const reset = bdd.resetRegistryToBuiltInSteps;
+  if (typeof reset !== 'function') {
+    throw new Error(
+      'Installed @letsrunit/bdd does not expose resetRegistryToBuiltInSteps. Update @letsrunit/bdd to a compatible version.',
+    );
+  }
+  reset();
+}
+
+export function registerReload(server: McpServer, options: Options): void {
+  server.registerTool(
+    'letsrunit_reload',
+    {
+      description:
+        'Reload built-in and project support step definitions without restarting the MCP server.',
+      inputSchema: {
+        cwd: z
+          .string()
+          .optional()
+          .describe('Project directory to resolve cucumber support files from. Defaults to current project cwd.'),
+      },
+    },
+    async (input) => {
+      if (options.runtimeMode !== 'project') {
+        return err('Reload failed: letsrunit_reload is only available in project runtime mode.');
+      }
+
+      try {
+        await resetBuiltInStepRegistry();
+        const result = await reloadSupportFiles(input.cwd);
+        return text(
+          JSON.stringify({
+            reloaded: true,
+            projectRoot: result.projectRoot,
+            supportEntriesLoaded: result.supportEntriesLoaded,
+            ignoredEntries: result.ignoredEntries,
+          }),
+        );
+      } catch (e) {
+        return err(`Reload failed: ${(e as Error).message}`);
+      }
+    },
+  );
+}

package/src/tools/session-start.ts

@@ -1,17 +1,27 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
+import type { McpRuntimeMode } from '../bootstrap';
 import type { SessionManager } from '../sessions';
 import { err, text } from '../utility/response';
 import { loadSupportFiles } from '../utility/support';
 
-export function registerSessionStart(server: McpServer, sessions: SessionManager): void {
+interface Options {
+  runtimeMode: McpRuntimeMode;
+}
+
+export function registerSessionStart(server: McpServer, sessions: SessionManager, opts?: Options): void {
   server.registerTool(
     'letsrunit_session_start',
     {
       description:
         'Launch a new browser session. Does not navigate anywhere — use letsrunit_run with a Given step to navigate. Set baseURL to enable relative paths like "Given I\'m on the homepage".',
       inputSchema: {
-        baseURL: z.string().optional().describe('Base URL for the session, e.g. "http://localhost:3000". Enables relative paths in Given steps like "Given I\'m on the homepage" or "Given I\'m on page \\"/login\\""'),
+        baseURL: z
+          .string()
+          .optional()
+          .describe(
+            'Base URL for the session, e.g. "http://localhost:3000". Enables relative paths in Given steps like "Given I\'m on the homepage" or "Given I\'m on page \\"/login\\""',
+          ),
         language: z.string().optional().describe("Browser language code, e.g. 'en', 'fr'"),
         headless: z.boolean().optional().describe('Run browser in headless mode (default: true)'),
         viewportWidth: z.number().int().optional().describe('Viewport width in pixels (default: 1280)'),
@@ -20,7 +30,7 @@ export function registerSessionStart(server: McpServer, sessions: SessionManager
     },
     async (input) => {
       try {
-        if (process.env.LETSRUNIT_MCP_RUNTIME_MODE === 'project') {
+        if (opts?.runtimeMode === 'project') {
           await loadSupportFiles();
         }
 

package/src/utility/diagnostics.ts

@@ -0,0 +1,159 @@
+import { loadConfiguration } from '@cucumber/cucumber/api';
+import { registry } from '@letsrunit/bdd';
+import { realpathSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { decideHandoff, resolveRuntimeModeOverride } from '../bootstrap';
+import {
+  expandPathPatterns,
+  findCucumberConfig,
+  getSupportLoadState,
+  loadLetsrunitIgnorePatterns,
+  resolveEffectiveCwd,
+  resolveSupportEntries,
+  type SupportEntry,
+} from './support';
+
+declare const __LETSRUNIT_VERSION__: string | undefined;
+
+export type Diagnostics = {
+  envProjectCwd: string | null;
+  processCwd: string;
+  inputCwd: string | null;
+  effectiveCwd: string;
+  projectRoot: string;
+  cucumberConfigPath: string | null;
+  supportPatterns: string[];
+  ignorePatterns: string[];
+  ignoredPaths: string[];
+  supportEntries: SupportEntry[];
+  loadedProjectRoots: string[];
+  loadedSupportEntries: string[];
+  mcpServer: {
+    version: string;
+    executablePath: string | null;
+    projectServerUsed: boolean;
+    handoffDecision: {
+      shouldHandoff: boolean;
+      runtimeMode: string;
+    };
+    serverMcpPath: string | null;
+    projectMcpPath: string | null;
+  };
+  letsrunitEnv: Record<string, string>;
+  moduleResolution: {
+    serverBddPath: string | null;
+    projectBddPath: string | null;
+  };
+  registry: {
+    total: number;
+    byType: {
+      Given: number;
+      When: number;
+      Then: number;
+    };
+    definitions: Array<{
+      type: 'Given' | 'When' | 'Then';
+      source: string;
+      comment?: string;
+    }>;
+  };
+};
+
+function resolveFrom(moduleId: string, fromPath: string): string | null {
+  try {
+    const req = createRequire(fromPath);
+    return req.resolve(moduleId);
+  } catch {
+    return null;
+  }
+}
+
+function toRealpath(path: string | null): string | null {
+  if (!path) return null;
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+
+function pickLetsrunitEnv(): Record<string, string> {
+  return Object.fromEntries(
+    Object.entries(process.env)
+      .filter(([key, value]) => key.startsWith('LETSRUNIT_') && typeof value === 'string')
+      .map(([key, value]) => [key, value as string]),
+  );
+}
+
+export async function collectDiagnostics(cwd?: string): Promise<Diagnostics> {
+  const effectiveCwd = resolveEffectiveCwd(cwd);
+  const projectRoot = resolve(effectiveCwd);
+  const cucumberConfigPath = findCucumberConfig(projectRoot);
+  const { useConfiguration } = await loadConfiguration({}, { cwd: projectRoot });
+  const supportPatterns = [...(useConfiguration.require ?? []), ...(useConfiguration.import ?? [])];
+  const ignorePatterns = await loadLetsrunitIgnorePatterns(projectRoot);
+  const ignoredPaths = await expandPathPatterns(projectRoot, ignorePatterns);
+  const supportEntries = await resolveSupportEntries(projectRoot, supportPatterns);
+  const supportLoadState = getSupportLoadState();
+  const serverBddPath = toRealpath(resolveFrom('@letsrunit/bdd', import.meta.url));
+  const projectBddPath = toRealpath(resolveFrom('@letsrunit/bdd', resolve(projectRoot, 'package.json')));
+  const projectMcpEntryPath = resolveFrom('@letsrunit/mcp-server', resolve(projectRoot, 'package.json'));
+  const currentEntrypointPath = toRealpath(fileURLToPath(import.meta.url));
+  const projectEntrypointPath = toRealpath(projectMcpEntryPath);
+  const handoffDecision = decideHandoff(
+    currentEntrypointPath,
+    projectEntrypointPath,
+    resolveRuntimeModeOverride(),
+  );
+  const serverMcpPath = toRealpath(resolveFrom('@letsrunit/mcp-server', import.meta.url));
+  const projectMcpPath = toRealpath(projectMcpEntryPath);
+  const executablePath = toRealpath(process.argv[1] ?? null);
+  const version = typeof __LETSRUNIT_VERSION__ === 'string' ? __LETSRUNIT_VERSION__ : 'unknown';
+  const registryDefinitions = registry.defs.map((def) => ({
+    type: def.type,
+    source: def.source,
+    comment: def.comment,
+  }));
+
+  return {
+    envProjectCwd: process.env.LETSRUNIT_PROJECT_CWD ?? null,
+    processCwd: process.cwd(),
+    inputCwd: cwd ?? null,
+    effectiveCwd,
+    projectRoot,
+    cucumberConfigPath,
+    supportPatterns,
+    ignorePatterns,
+    ignoredPaths: [...ignoredPaths].sort(),
+    supportEntries,
+    loadedProjectRoots: supportLoadState.loadedProjectRoots,
+    loadedSupportEntries: supportLoadState.loadedSupportEntries,
+    mcpServer: {
+      version,
+      executablePath,
+      projectServerUsed: handoffDecision.runtimeMode === 'project',
+      handoffDecision: {
+        shouldHandoff: handoffDecision.shouldHandoff,
+        runtimeMode: handoffDecision.runtimeMode,
+      },
+      serverMcpPath,
+      projectMcpPath,
+    },
+    letsrunitEnv: pickLetsrunitEnv(),
+    moduleResolution: {
+      serverBddPath,
+      projectBddPath,
+    },
+    registry: {
+      total: registryDefinitions.length,
+      byType: {
+        Given: registryDefinitions.filter((d) => d.type === 'Given').length,
+        When: registryDefinitions.filter((d) => d.type === 'When').length,
+        Then: registryDefinitions.filter((d) => d.type === 'Then').length,
+      },
+      definitions: registryDefinitions,
+    },
+  };
+}

package/src/utility/support.ts

@@ -1,13 +1,8 @@
 import { loadConfiguration } from '@cucumber/cucumber/api';
-import { registry } from '@letsrunit/bdd';
-import { existsSync, realpathSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import { glob } from 'node:fs/promises';
-import { createRequire } from 'node:module';
 import { isAbsolute, resolve } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { decideHandoff } from '../bootstrap';
-
-declare const __LETSRUNIT_VERSION__: string;
+import { pathToFileURL } from 'node:url';
 
 type CucumberConfig = {
   require?: unknown;
@@ -17,7 +12,7 @@ type CucumberConfig = {
   };
 };
 
-type SupportEntry = { kind: 'path'; value: string } | { kind: 'module'; value: string };
+export type SupportEntry = { kind: 'path'; value: string } | { kind: 'module'; value: string };
 
 const CUCUMBER_CONFIG_FILES = [
   'cucumber.js',
@@ -31,48 +26,14 @@ const CUCUMBER_CONFIG_FILES = [
 const loadedProjectRoots = new Set<string>();
 const loadedSupportEntries = new Set<string>();
 
-export type SupportDiagnostics = {
-  envProjectCwd: string | null;
-  processCwd: string;
-  inputCwd: string | null;
-  effectiveCwd: string;
+export type SupportLoadResult = {
   projectRoot: string;
-  cucumberConfigPath: string | null;
-  supportPatterns: string[];
-  ignorePatterns: string[];
-  ignoredPaths: string[];
-  supportEntries: SupportEntry[];
-  loadedProjectRoots: string[];
-  loadedSupportEntries: string[];
-  mcpServer: {
-    version: string;
-    executablePath: string | null;
-    projectServerUsed: boolean;
-    handoffDecision: {
-      shouldHandoff: boolean;
-      runtimeMode: string;
-    };
-    serverMcpPath: string | null;
-    projectMcpPath: string | null;
-  };
-  letsrunitEnv: Record<string, string>;
-  moduleResolution: {
-    serverBddPath: string | null;
-    projectBddPath: string | null;
-  };
-  registry: {
-    total: number;
-    byType: {
-      Given: number;
-      When: number;
-      Then: number;
-    };
-    definitions: Array<{
-      type: 'Given' | 'When' | 'Then';
-      source: string;
-      comment?: string;
-    }>;
-  };
+  supportEntriesLoaded: number;
+  ignoredEntries: number;
+};
+
+type LoadSupportOptions = {
+  forceReload?: boolean;
 };
 
 function toStrings(value: unknown): string[] {
@@ -96,7 +57,7 @@ function normalizeMatch(baseDir: string, match: string): string {
   return isAbsolute(match) ? resolve(match) : resolve(baseDir, match);
 }
 
-async function expandPathPatterns(baseDir: string, patterns: string[]): Promise<Set<string>> {
+export async function expandPathPatterns(baseDir: string, patterns: string[]): Promise<Set<string>> {
   const files = new Set<string>();
 
   for (const pattern of patterns) {
@@ -113,7 +74,7 @@ async function expandPathPatterns(baseDir: string, patterns: string[]): Promise<
   return files;
 }
 
-async function resolveSupportEntries(baseDir: string, entries: string[]): Promise<SupportEntry[]> {
+export async function resolveSupportEntries(baseDir: string, entries: string[]): Promise<SupportEntry[]> {
   const resolved: SupportEntry[] = [];
 
   for (const entry of entries) {
@@ -135,7 +96,7 @@ async function resolveSupportEntries(baseDir: string, entries: string[]): Promis
   return resolved;
 }
 
-function findCucumberConfig(cwd: string): string | null {
+export function findCucumberConfig(cwd: string): string | null {
   for (const filename of CUCUMBER_CONFIG_FILES) {
     const path = resolve(cwd, filename);
     if (existsSync(path)) return path;
@@ -144,7 +105,7 @@ function findCucumberConfig(cwd: string): string | null {
   return null;
 }
 
-async function loadLetsrunitIgnorePatterns(cwd: string): Promise<string[]> {
+export async function loadLetsrunitIgnorePatterns(cwd: string): Promise<string[]> {
   const configPath = findCucumberConfig(cwd);
   if (!configPath) return [];
 
@@ -154,141 +115,73 @@ async function loadLetsrunitIgnorePatterns(cwd: string): Promise<string[]> {
   return toStrings(config.letsrunit?.ignore);
 }
 
-function resolveEffectiveCwd(cwd?: string): string {
+export function resolveEffectiveCwd(cwd?: string): string {
   return cwd ?? process.env.LETSRUNIT_PROJECT_CWD ?? process.cwd();
 }
 
-function resolveFrom(moduleId: string, fromPath: string): string | null {
-  try {
-    const req = createRequire(fromPath);
-    return req.resolve(moduleId);
-  } catch {
-    return null;
-  }
-}
-
-function toRealpath(path: string | null): string | null {
-  if (!path) return null;
-  try {
-    return realpathSync(path);
-  } catch {
-    return path;
-  }
-}
-
-function pickLetsrunitEnv(): Record<string, string> {
-  return Object.fromEntries(
-    Object.entries(process.env)
-      .filter(([key, value]) => key.startsWith('LETSRUNIT_') && typeof value === 'string')
-      .map(([key, value]) => [key, value as string]),
-  );
-}
-
-function resolveMcpServerVersion(): string {
-  return typeof __LETSRUNIT_VERSION__ === 'string' ? __LETSRUNIT_VERSION__ : 'unknown';
-}
-
-export async function collectSupportDiagnostics(cwd?: string): Promise<SupportDiagnostics> {
-  const effectiveCwd = resolveEffectiveCwd(cwd);
-  const projectRoot = resolve(effectiveCwd);
-  const cucumberConfigPath = findCucumberConfig(projectRoot);
-  const { useConfiguration } = await loadConfiguration({}, { cwd: projectRoot });
-  const supportPatterns = [...toStrings(useConfiguration.require), ...toStrings(useConfiguration.import)];
-  const ignorePatterns = await loadLetsrunitIgnorePatterns(projectRoot);
-  const ignoredPaths = await expandPathPatterns(projectRoot, ignorePatterns);
-  const supportEntries = await resolveSupportEntries(projectRoot, supportPatterns);
-  const serverBddPath = toRealpath(resolveFrom('@letsrunit/bdd', import.meta.url));
-  const projectBddPath = toRealpath(resolveFrom('@letsrunit/bdd', resolve(projectRoot, 'package.json')));
-  const projectMcpEntryPath = resolveFrom('@letsrunit/mcp-server', resolve(projectRoot, 'package.json'));
-  const currentEntrypointPath = toRealpath(fileURLToPath(import.meta.url));
-  const projectEntrypointPath = toRealpath(projectMcpEntryPath);
-  const handoffDecision = decideHandoff(
-    currentEntrypointPath,
-    projectEntrypointPath,
-    process.env.LETSRUNIT_MCP_BOOTSTRAPPED === '1',
-  );
-  const serverMcpPath = toRealpath(resolveFrom('@letsrunit/mcp-server', import.meta.url));
-  const projectMcpPath = toRealpath(projectMcpEntryPath);
-  const executablePath = toRealpath(process.argv[1] ?? null);
-  const version = resolveMcpServerVersion();
-  const registryDefinitions = registry.defs.map((def) => ({
-    type: def.type,
-    source: def.source,
-    comment: def.comment,
-  }));
-
+export function getSupportLoadState(): { loadedProjectRoots: string[]; loadedSupportEntries: string[] } {
   return {
-    envProjectCwd: process.env.LETSRUNIT_PROJECT_CWD ?? null,
-    processCwd: process.cwd(),
-    inputCwd: cwd ?? null,
-    effectiveCwd,
-    projectRoot,
-    cucumberConfigPath,
-    supportPatterns,
-    ignorePatterns,
-    ignoredPaths: [...ignoredPaths].sort(),
-    supportEntries,
     loadedProjectRoots: [...loadedProjectRoots].sort(),
     loadedSupportEntries: [...loadedSupportEntries].sort(),
-    mcpServer: {
-      version,
-      executablePath,
-      projectServerUsed: handoffDecision.runtimeMode === 'project',
-      handoffDecision: {
-        shouldHandoff: handoffDecision.shouldHandoff,
-        runtimeMode: handoffDecision.runtimeMode,
-      },
-      serverMcpPath,
-      projectMcpPath,
-    },
-    letsrunitEnv: pickLetsrunitEnv(),
-    moduleResolution: {
-      serverBddPath,
-      projectBddPath,
-    },
-    registry: {
-      total: registryDefinitions.length,
-      byType: {
-        Given: registryDefinitions.filter((d) => d.type === 'Given').length,
-        When: registryDefinitions.filter((d) => d.type === 'When').length,
-        Then: registryDefinitions.filter((d) => d.type === 'Then').length,
-      },
-      definitions: registryDefinitions,
-    },
   };
 }
 
-export async function loadSupportFiles(cwd?: string): Promise<void> {
+export function clearSupportLoadState(): void {
+  loadedProjectRoots.clear();
+  loadedSupportEntries.clear();
+}
+
+function buildReloadedFileUrl(path: string): string {
+  const url = pathToFileURL(path);
+  url.searchParams.set('letsrunitReload', Date.now().toString(36));
+  return url.href;
+}
+
+export async function loadSupportFiles(cwd?: string, options?: LoadSupportOptions): Promise<SupportLoadResult> {
   const projectRoot = resolve(resolveEffectiveCwd(cwd));
-  if (loadedProjectRoots.has(projectRoot)) return;
+  const forceReload = options?.forceReload === true;
+
+  if (!forceReload && loadedProjectRoots.has(projectRoot)) {
+    return { projectRoot, supportEntriesLoaded: 0, ignoredEntries: 0 };
+  }
 
   const { useConfiguration } = await loadConfiguration({}, { cwd: projectRoot });
   const supportPatterns = [...toStrings(useConfiguration.require), ...toStrings(useConfiguration.import)];
   if (supportPatterns.length === 0) {
     loadedProjectRoots.add(projectRoot);
-    return;
+    return { projectRoot, supportEntriesLoaded: 0, ignoredEntries: 0 };
   }
 
   const ignorePatterns = await loadLetsrunitIgnorePatterns(projectRoot);
   const ignoredPaths = await expandPathPatterns(projectRoot, ignorePatterns);
   const supportEntries = await resolveSupportEntries(projectRoot, supportPatterns);
+  let supportEntriesLoaded = 0;
+  let ignoredEntries = 0;
 
   for (const entry of supportEntries) {
     if (entry.kind === 'path' && ignoredPaths.has(entry.value)) {
+      ignoredEntries += 1;
       continue;
     }
 
     const key = `${entry.kind}:${entry.value}`;
-    if (loadedSupportEntries.has(key)) continue;
+    if (!forceReload && loadedSupportEntries.has(key)) continue;
 
     if (entry.kind === 'path') {
-      await import(pathToFileURL(entry.value).href);
+      await import(forceReload ? buildReloadedFileUrl(entry.value) : pathToFileURL(entry.value).href);
     } else {
       await import(entry.value);
     }
 
+    supportEntriesLoaded += 1;
     loadedSupportEntries.add(key);
   }
 
   loadedProjectRoots.add(projectRoot);
+  return { projectRoot, supportEntriesLoaded, ignoredEntries };
+}
+
+export async function reloadSupportFiles(cwd?: string): Promise<SupportLoadResult> {
+  clearSupportLoadState();
+  return loadSupportFiles(cwd, { forceReload: true });
 }

package/dist/chunk-XJCBPTOU.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/bootstrap.ts"],"names":[],"mappings":"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","file":"chunk-XJCBPTOU.js","sourcesContent":["import { spawnSync } from 'node:child_process';\nimport { realpathSync } from 'node:fs';\nimport { createRequire } from 'node:module';\nimport { resolve } from 'node:path';\nimport { fileURLToPath } from 'node:url';\n\nexport type McpRuntimeMode = 'project' | 'standalone';\n\nexport type HandoffDecision = {\n  shouldHandoff: boolean;\n  runtimeMode: McpRuntimeMode;\n};\n\nfunction resolveProjectRoot(): string {\n  return resolve(process.env.LETSRUNIT_PROJECT_CWD ?? process.cwd());\n}\n\nfunction resolveFromProject(moduleId: string, projectRoot: string): string | null {\n  try {\n    const req = createRequire(resolve(projectRoot, 'package.json'));\n    return req.resolve(moduleId);\n  } catch {\n    return null;\n  }\n}\n\nfunction toRealpath(path: string | null): string | null {\n  if (!path) return null;\n  try {\n    return realpathSync(path);\n  } catch {\n    return null;\n  }\n}\n\nfunction sameEntrypoint(a: string | null, b: string | null): boolean {\n  if (!a || !b) return false;\n  return a === b;\n}\n\nexport function decideHandoff(\n  currentEntrypointPath: string | null,\n  projectEntrypointPath: string | null,\n  isBootstrapped: boolean,\n): HandoffDecision {\n  if (!projectEntrypointPath) {\n    return { shouldHandoff: false, runtimeMode: 'standalone' };\n  }\n\n  if (sameEntrypoint(currentEntrypointPath, projectEntrypointPath)) {\n    return { shouldHandoff: false, runtimeMode: 'project' };\n  }\n\n  if (isBootstrapped) {\n    return { shouldHandoff: false, runtimeMode: 'standalone' };\n  }\n\n  return { shouldHandoff: true, runtimeMode: 'project' };\n}\n\nfunction runProjectLocalServer(projectEntrypointPath: string): never {\n  const result = spawnSync(process.execPath, [projectEntrypointPath, ...process.argv.slice(2)], {\n    stdio: 'inherit',\n    env: {\n      ...process.env,\n      LETSRUNIT_MCP_BOOTSTRAPPED: '1',\n      LETSRUNIT_MCP_RUNTIME_MODE: 'project',\n    },\n  });\n\n  if (result.error) throw result.error;\n  process.exit(result.status ?? 1);\n}\n\nexport function bootstrapProjectServer(): McpRuntimeMode {\n  const projectRoot = resolveProjectRoot();\n  const isBootstrapped = process.env.LETSRUNIT_MCP_BOOTSTRAPPED === '1';\n\n  const currentEntryPath = toRealpath(fileURLToPath(import.meta.url));\n  const projectEntryPath = toRealpath(resolveFromProject('@letsrunit/mcp-server', projectRoot));\n\n  const decision = decideHandoff(currentEntryPath, projectEntryPath, isBootstrapped);\n\n  if (decision.shouldHandoff && projectEntryPath) {\n    runProjectLocalServer(projectEntryPath);\n  }\n\n  process.env.LETSRUNIT_MCP_RUNTIME_MODE = decision.runtimeMode;\n  return decision.runtimeMode;\n}\n"]}