@vitest-agent/mcp 5.1.1 → 5.1.2

package/index.d.ts

@@ -2,6 +2,7 @@ import { ToolRefusal } from "@effected/mcp";
 import { Context, Effect, Layer, Schema, Stdio } from "effect";
 import { DataReader, DataStore, ProjectDiscovery, SessionContext } from "@vitest-agent/engine";
 import { Toolkit } from "effect/ai";
+import "@effected/git";
 import "@vitest-agent/sdk";
 import { Remediation } from "@effected/engine";
 //#region src/annotations.d.ts

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/mcp",
-	"version": "5.1.1",
+	"version": "5.1.2",
 	"private": false,
 	"description": "Model Context Protocol server for vitest-agent. Exposes 30 tools for agent access to test data, TDD lifecycle, and session management.",
 	"keywords": [
@@ -46,8 +46,10 @@
 		"@effect/platform-node": "4.0.0-rc.118",
 		"@effect/sql-sqlite-node": "4.0.0-rc.118",
 		"@effected/engine": "^0.2.0",
+		"@effected/git": "^0.19.0",
 		"@effected/mcp": "^0.3.0",
-		"@vitest-agent/engine": "0.2.10",
+		"@effected/walker": "^0.14.0",
+		"@vitest-agent/engine": "0.2.11",
 		"@vitest-agent/sdk": "5.1.3",
 		"effect": "4.0.0-rc.118"
 	},

package/tools/run-tests.js

@@ -1,19 +1,20 @@
 import { McpSession } from "../session.js";
 import { createRequire } from "node:module";
 import { ToolOutputSchema } from "@effected/mcp";
-import { Data, Effect, Schema, Semaphore } from "effect";
+import { Data, Effect, Layer, Option, Path, Result, Schema, Semaphore } from "effect";
 import { DataReader, DataStore } from "@vitest-agent/engine";
 import { Tool } from "effect/ai";
 import { AgentReport, buildAgentReport, buildConsoleLeaks, coerceErrorField, collectConsoleLeakEntries, formatScopedCoverageNote } from "@vitest-agent/sdk";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { execFile } from "node:child_process";
 import { existsSync, mkdtempSync, rmSync } from "node:fs";
-import { realpath, stat } from "node:fs/promises";
+import { stat } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { join, resolve } from "node:path";
 import { Writable } from "node:stream";
-import { pathToFileURL } from "node:url";
-import { promisify } from "node:util";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { NodeChildProcessSpawner, NodeFileSystem, NodePath } from "@effect/platform-node";
+import { Git } from "@effected/git";
+import { Walker } from "@effected/walker";
 
 //#region src/tools/run-tests.ts
 const TagFilter = Schema.Struct({
@@ -186,29 +187,18 @@ function sanitizeTestArgs(args) {
 	}
 	return result;
 }
-const execFileAsync = promisify(execFile);
 /**
-* Resolve the git common directory for `dir` (`git rev-parse
-* --git-common-dir`) — identical across a repository and every worktree
-* attached to it, which is what makes it the right "same repository"
-* comparison (a plain `--show-toplevel` differs per worktree). Returns
-* `null` when `dir` is not inside a git repository or the command fails
-* for any other reason; callers treat `null` as "cannot confirm same
-* repository", never as a silent pass.
-*
-* @internal exported for tests
+* The git common directory for `dir` (`Git.commonDir`: `git rev-parse
+* --path-format=absolute --git-common-dir`) — identical across a
+* repository, its subdirectories, every linked worktree and any symlinked
+* path to them, which is what makes it the right "same repository"
+* comparison (`--show-toplevel` differs per worktree). Yields `null` when
+* `dir` is not inside a git repository or the command fails for any other
+* reason; callers treat `null` as "cannot confirm same repository", never
+* as a silent pass.
 */
-async function resolveGitCommonDir(dir) {
-	try {
-		const { stdout } = await execFileAsync("git", ["rev-parse", "--git-common-dir"], { cwd: dir });
-		const trimmed = stdout.trim();
-		if (trimmed.length === 0) return null;
-		const candidate = resolve(dir, trimmed);
-		return await realpath(candidate);
-	} catch {
-		return null;
-	}
-}
+const gitCommonDir = (dir) => Effect.flatMap(Git, (git) => git.commonDir(dir)).pipe(Effect.option, Effect.map(Option.getOrNull), Effect.catchDefect(() => Effect.succeed(null)));
+const VITEST_CONFIG_PREFIXES = ["vitest.config.", "vite.config."];
 const VITEST_CONFIG_EXTENSIONS = [
 	"ts",
 	"mts",
@@ -217,57 +207,54 @@ const VITEST_CONFIG_EXTENSIONS = [
 	"mjs",
 	"cjs"
 ];
-function findConfigInDir(dir) {
-	for (const prefix of ["vitest.config.", "vite.config."]) for (const ext of VITEST_CONFIG_EXTENSIONS) {
-		const candidate = join(dir, `${prefix}${ext}`);
-		if (existsSync(candidate)) return candidate;
-	}
-	return null;
-}
 /**
 * The one walk both anchoring helpers share: step UP from `startDir`
 * until a vitest/vite config file is found, returning its absolute path.
-* Bounded at the git root (inclusive — the directory containing `.git`
-* is still examined before the walk stops) and at the filesystem root.
-* Returns `null` when no config is found in range or when anything about
-* the walk throws.
+* Bounded at the git work-tree root (inclusive, so the root is still
+* examined) and at the filesystem root. `Git.repoRoot` answers a PHYSICAL
+* path (`/private/var/...` for a `/var/...` tmpdir on macOS) while the chain
+* is lexical, so the bound is `Walker.ascendWithin`, which stops on a
+* realpath match; a lexical `stopAt` would match nothing there and let the
+* walk run past the repository. Any `repoRoot` failure (not a repository,
+* git missing) means no git bound: the walk runs to the filesystem root, as
+* it always has outside a repository. Yields `null` when no config is found in
+* range. An unreadable entry reads as absent (the walker absorbs
+* per-candidate failures), and a defect anywhere in the walk also yields
+* `null`, so the helper never fails.
 */
-function walkUpToConfigFile(startDir) {
-	try {
-		let dir = resolve(startDir);
-		for (;;) {
-			const found = findConfigInDir(dir);
-			if (found !== null) return found;
-			if (existsSync(join(dir, ".git"))) return null;
-			const parent = dirname(dir);
-			if (parent === dir) return null;
-			dir = parent;
-		}
-	} catch {
-		return null;
-	}
-}
+const walkUpToConfigFile = (startDir) => Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const start = path.resolve(startDir);
+	const git = yield* Git;
+	const dirs = yield* Walker.ascendWithin(start, yield* Effect.option(git.repoRoot(start)));
+	const found = yield* Walker.findUpward(dirs, (dir) => VITEST_CONFIG_PREFIXES.flatMap((prefix) => VITEST_CONFIG_EXTENSIONS.map((ext) => path.join(dir, `${prefix}${ext}`))));
+	return Option.getOrNull(found);
+}).pipe(Effect.catchDefect(() => Effect.succeed(null)));
 /**
-* Walk UP from `startDir` looking for the vitest/vite config file, returning
+* Walk UP from `startDir` looking for the vitest/vite config file, yielding
 * its absolute path, or `null` when none is found in range.
 *
 * @internal exported for tests
 */
-function resolveAnchoredConfigFile(startDir) {
-	return walkUpToConfigFile(startDir);
-}
+const resolveAnchoredConfigFile = (startDir) => walkUpToConfigFile(startDir);
 /**
 * Walk UP from `startDir` looking for the vitest/vite config Vitest would
-* load anyway, returning the directory that holds it. Returns `startDir`
+* load anyway, yielding the directory that holds it. Yields `startDir`
 * unchanged when no config is found in range. See the issue #259 comment
 * above `validateProjectRoot` for the full rationale.
 *
 * @internal exported for tests
 */
-function resolveConfigAnchoredRoot(startDir) {
-	const found = walkUpToConfigFile(startDir);
-	return found === null ? startDir : dirname(found);
-}
+const resolveConfigAnchoredRoot = (startDir) => Effect.gen(function* () {
+	const found = yield* walkUpToConfigFile(startDir);
+	if (found === null) return startDir;
+	return (yield* Path.Path).dirname(found);
+});
+const NodeFsPath = Layer.mergeAll(NodeFileSystem.layer, NodePath.layer);
+/** The Node platform the promise-shaped run body walks the real disk with; bound once so it memoizes. */
+const NodeWalkPlatform = Git.layer.pipe(Layer.provide(NodeChildProcessSpawner.layer), Layer.provideMerge(NodeFsPath));
+/** Run a never-failing platform walk against the real disk. */
+const runOnNodePlatform = (effect) => Effect.runPromise(Effect.provide(effect, NodeWalkPlatform));
 /**
 * Validate an optional caller-supplied `projectRoot` against `ctxCwd`
 * (the MCP server's boot-time root). `undefined` anchors at the directory
@@ -290,7 +277,7 @@ function resolveConfigAnchoredRoot(startDir) {
 async function validateProjectRoot(projectRoot, ctxCwd) {
 	if (projectRoot === void 0) return {
 		ok: true,
-		root: resolveConfigAnchoredRoot(ctxCwd)
+		root: await runOnNodePlatform(resolveConfigAnchoredRoot(ctxCwd))
 	};
 	const resolvedRoot = resolve(ctxCwd, projectRoot);
 	let isDirectory;
@@ -306,7 +293,7 @@ async function validateProjectRoot(projectRoot, ctxCwd) {
 		ok: false,
 		message: `projectRoot "${resolvedRoot}" is not a directory (ctx.cwd is "${ctxCwd}").`
 	};
-	const [rootCommonDir, cwdCommonDir] = await Promise.all([resolveGitCommonDir(resolvedRoot), resolveGitCommonDir(ctxCwd)]);
+	const [rootCommonDir, cwdCommonDir] = await runOnNodePlatform(Effect.all([gitCommonDir(resolvedRoot), gitCommonDir(ctxCwd)], { concurrency: 2 }));
 	if (rootCommonDir === null || cwdCommonDir === null || rootCommonDir !== cwdCommonDir) return {
 		ok: false,
 		message: `projectRoot "${resolvedRoot}" does not belong to the same git repository as ctx.cwd "${ctxCwd}".`
@@ -355,6 +342,25 @@ function resolveVitestNodeEntry(root) {
 	}
 }
 /**
+* Issue #461: the MCP server is long-lived. When the lockfile is regenerated
+* mid-session (dep bump, branch switch), pnpm can rename vitest's `.pnpm`
+* store directory (peer-hash change), so the entry resolved for this process
+* no longer exists and every run would otherwise fail opaquely inside the fork
+* pool ("Worker forks emitted error", total: 0). Returns an actionable message
+* when `entry` is a `file://` URL whose path is missing on disk, else `null`.
+* The bare `"vitest/node"` fallback is not a path and is never checked. The
+* check is on the exact path that will be imported, because Node's require
+* resolution caches can hand back a stale path in a long-lived process.
+*
+* @internal exported for tests
+*/
+function staleInstallMessage(entry) {
+	if (!entry.startsWith("file:")) return null;
+	const path = fileURLToPath(entry);
+	if (existsSync(path)) return null;
+	return `The resolved vitest entry "${path}" no longer exists on disk. The install changed since this vitest-agent MCP server loaded it (for example the lockfile was regenerated by a dependency install or branch switch). Restart the vitest-agent MCP server (in Claude Code: /mcp) or restart the session, then retry.`;
+}
+/**
 * Indirection seam around `import(<vitest/node entry>)`. vitest's own
 * vite-node externalizes "vitest"/"vitest/node" for every importer, and
 * `vi.mock("vitest/node", ...)` only special-cases AST-literal
@@ -366,7 +372,10 @@ function resolveVitestNodeEntry(root) {
 *
 * @internal exported for tests
 */
-const vitestLoader = { load: (entry) => import(entry) };
+const vitestLoader = {
+	resolveEntry: (root) => resolveVitestNodeEntry(root),
+	load: (entry) => import(entry)
+};
 const runTestsSemaphore = Effect.runSync(Semaphore.make(1));
 /**
 * Coerce unknown Vitest unhandled errors into VitestModuleError shape.
@@ -394,7 +403,7 @@ function coerceErrors(errors) {
 const RunTestsInput = Schema.Struct({
 	files: Schema.optionalKey(Schema.Array(Schema.String)).annotate({ description: "Test file paths to run" }),
 	project: Schema.optionalKey(Schema.String).annotate({ description: "Project name to filter" }),
-	projectRoot: Schema.optionalKey(Schema.String).annotate({ description: "Explicit Vitest root for this call, used verbatim. Omit it to get the config-anchored default (walk up from the server's boot dir for a vitest/vite config, bounded at the git root). Prefer an absolute path; a relative path is resolved against ctx.cwd, not the server process's cwd. Validated: must be an existing directory in the same git repository as ctx.cwd (same git-common-dir, e.g. a sibling worktree). Rejected with { kind: 'error' } naming both paths otherwise." }),
+	projectRoot: Schema.optionalKey(Schema.String).annotate({ description: "Explicit Vitest root for this call, used verbatim. Omit it to get the config-anchored default (walk up from the server's boot dir for a vitest/vite config, bounded at the git root). Prefer an absolute path; a relative path is resolved against ctx.cwd, not the server process's cwd. Validated: must be an existing directory in the same git repository as ctx.cwd (same git-common-dir, compared via `git rev-parse --path-format=absolute --git-common-dir`, which requires git 2.31 or newer; e.g. a sibling worktree). Rejected with { kind: 'error' } naming both paths otherwise." }),
 	tags: Schema.optionalKey(TagFilter).annotate({ description: "Structured tag filter; all/any/none AND together with each other and with project/files" }),
 	passWithNoTests: Schema.optionalKey(Schema.Boolean).annotate({ description: "Per-call override of Vitest's native test.passWithNoTests" }),
 	timeout: Schema.optionalKey(Schema.Finite).annotate({ description: "Timeout in seconds (default: 120)" }),
@@ -405,6 +414,92 @@ const RunTestsInput = Schema.Struct({
 	})).annotate({ description: "Hook-injected session attribution UUIDs; do not pass manually." })
 });
 /**
+* Derive the run's {@link RunScope} from its input. Every file, project and
+* tag value passes through `sanitizeTestArgs` (tag values ride into Vitest's
+* tag-expression compiler unmodified, so shell metacharacters are rejected
+* the same way); a refused argument fails with the message the tool returns
+* as its `{ kind: "error" }` result. An all-empty tag filter composes to no
+* expression and so is not a filter.
+*
+* @internal exported for tests
+*/
+function deriveRunScope(input) {
+	const tags = input.tags;
+	try {
+		const files = input.files ? sanitizeTestArgs(input.files) : [];
+		const project = input.project ? sanitizeTestArgs([input.project])[0] : void 0;
+		if (tags) {
+			if (tags.all) sanitizeTestArgs(tags.all);
+			if (tags.any) sanitizeTestArgs(tags.any);
+			if (tags.none) sanitizeTestArgs(tags.none);
+		}
+		const resolvedExpression = composeTagExpression(tags ?? null);
+		const hasFilter = files.length > 0 || project !== void 0 || resolvedExpression !== null;
+		return Result.succeed({
+			files,
+			project,
+			tags,
+			resolvedExpression,
+			hasFilter
+		});
+	} catch (err) {
+		return Result.fail(err instanceof Error ? err.message : String(err));
+	}
+}
+/**
+* Whether a finished run is `no-match`: a filter was supplied, no test
+* module was collected, and no unhandled error was raised. Filter-driven,
+* not result-driven — an unfiltered empty run is `ok`, and the
+* `passWithNoTests` policy never reshapes the discriminator.
+*
+* @internal exported for tests
+*/
+function isNoMatch(scope, testModuleCount, unhandledErrorCount) {
+	return scope.hasFilter && testModuleCount === 0 && unhandledErrorCount === 0;
+}
+/**
+* Shape the `no-match` result, echoing the resolved filter verbatim.
+*
+* @internal exported for tests
+*/
+function toNoMatch(scope, projectRoot) {
+	return {
+		kind: "no-match",
+		projectRoot,
+		filter: {
+			project: scope.project ?? null,
+			files: scope.files,
+			tags: scope.tags ?? null,
+			resolvedExpression: scope.resolvedExpression
+		}
+	};
+}
+/**
+* Shape the `ok` result from a finished run's plain values. `project` is
+* echoed at the top level only when supplied; `scope` always echoes the
+* resolved filter set; absent classifications and scan time become `{}` and
+* `null`.
+*
+* @internal exported for tests
+*/
+function toOkPayload(args) {
+	const { scope } = args;
+	return {
+		kind: "ok",
+		...scope.project !== void 0 && { project: scope.project },
+		projectRoot: args.projectRoot,
+		scope: {
+			project: scope.project ?? null,
+			files: scope.files,
+			tags: scope.tags ?? null
+		},
+		report: args.report,
+		classifications: args.classifications ? Object.fromEntries(args.classifications) : {},
+		discoveryLastScannedAt: args.discoveryLastScannedAt ?? null,
+		scopedNote: args.scopedNote
+	};
+}
+/**
 * Build the best-effort runner for a `RunTestsContext`: forks the effect
 * as a fiber on the provided services with its expected failure channel
 * ignored (`Effect.ignore`), so a typed failure never touches the tool
@@ -421,25 +516,13 @@ const makeBestEffortFork = (services) => (effect) => Effect.runFork(Effect.provi
 * `{ kind: "error" }` envelope, so it never rejects.
 */
 const runTestsBody = async (input, ctx) => {
-	let files;
-	let project;
-	const tagsInput = input.tags;
-	try {
-		files = input.files ? sanitizeTestArgs(input.files) : [];
-		project = input.project ? sanitizeTestArgs([input.project])[0] : void 0;
-		if (tagsInput) {
-			if (tagsInput.all) sanitizeTestArgs(tagsInput.all);
-			if (tagsInput.any) sanitizeTestArgs(tagsInput.any);
-			if (tagsInput.none) sanitizeTestArgs(tagsInput.none);
-		}
-	} catch (err) {
-		return {
-			kind: "error",
-			message: err instanceof Error ? err.message : String(err)
-		};
-	}
-	const resolvedExpression = composeTagExpression(tagsInput ?? null);
-	const hasFilter = files.length > 0 || project !== void 0 || resolvedExpression !== null;
+	const derived = deriveRunScope(input);
+	if (Result.isFailure(derived)) return {
+		kind: "error",
+		message: derived.failure
+	};
+	const scope = derived.success;
+	const { files, project, resolvedExpression, hasFilter } = scope;
 	const projectRootValidation = await validateProjectRoot(input.projectRoot, ctx.cwd);
 	if (!projectRootValidation.ok) return {
 		kind: "error",
@@ -448,13 +531,19 @@ const runTestsBody = async (input, ctx) => {
 	const resolvedRoot = projectRootValidation.root;
 	let anchoredConfig;
 	if (input.projectRoot !== void 0) {
-		const found = resolveAnchoredConfigFile(resolvedRoot);
+		const found = await runOnNodePlatform(resolveAnchoredConfigFile(resolvedRoot));
 		if (found === null) return {
 			kind: "error",
 			message: `No vitest.config.* or vite.config.* was found at or above projectRoot "${resolvedRoot}" within the repository. Vitest 5 does not search ancestor directories, so this run would collect no tests and load no plugins. Pass a projectRoot that contains a Vitest config, or omit projectRoot to anchor automatically.`
 		};
 		anchoredConfig = found;
 	}
+	const vitestEntry = vitestLoader.resolveEntry(resolvedRoot);
+	const staleMessage = staleInstallMessage(vitestEntry);
+	if (staleMessage !== null) return {
+		kind: "error",
+		message: staleMessage
+	};
 	const timeoutMs = (input.timeout ?? 120) * 1e3;
 	const recovered = input._sessionContext ?? null ?? ctx.sessionContext.get();
 	if (recovered !== null) {
@@ -465,10 +554,17 @@ const runTestsBody = async (input, ctx) => {
 	const nullStream = new Writable({ write(_chunk, _encoding, cb) {
 		cb();
 	} });
-	const { createVitest } = await vitestLoader.load(resolveVitestNodeEntry(resolvedRoot));
+	const { createVitest } = await vitestLoader.load(vitestEntry);
 	let vitest;
 	let covOverride;
+	let previousCwd;
+	try {
+		previousCwd = process.cwd();
+	} catch {
+		previousCwd = void 0;
+	}
 	try {
+		process.chdir(resolvedRoot);
 		covOverride = makeCoverageDirOverride();
 		vitest = await createVitest({
 			root: resolvedRoot,
@@ -501,16 +597,7 @@ const runTestsBody = async (input, ctx) => {
 		const result = startOutcome.value;
 		const testModules = result.testModules;
 		const unhandledErrors = coerceErrors(result.unhandledErrors);
-		if (hasFilter && result.testModules.length === 0 && unhandledErrors.length === 0) return {
-			kind: "no-match",
-			projectRoot: resolvedRoot,
-			filter: {
-				project: project ?? null,
-				files,
-				tags: tagsInput ?? null,
-				resolvedExpression
-			}
-		};
+		if (isNoMatch(scope, result.testModules.length, unhandledErrors.length)) return toNoMatch(scope, resolvedRoot);
 		const preliminaryReason = unhandledErrors.length > 0 || result.testModules.some((m) => m.state() === "failed") ? "failed" : "passed";
 		const baseReport = buildAgentReport(testModules, unhandledErrors, preliminaryReason, { omitPassingTests: true });
 		const leaks = buildConsoleLeaks(collectConsoleLeakEntries(localVitest.state.getFiles()));
@@ -547,20 +634,14 @@ const runTestsBody = async (input, ctx) => {
 			} catch {}
 			scopedNote = formatScopedCoverageNote(testedFileCount, totalFileCount);
 		}
-		return {
-			kind: "ok",
-			...project !== void 0 && { project },
+		return toOkPayload({
+			scope,
 			projectRoot: resolvedRoot,
-			scope: {
-				project: project ?? null,
-				files,
-				tags: tagsInput ?? null
-			},
 			report,
-			classifications: classifications ? Object.fromEntries(classifications) : {},
-			discoveryLastScannedAt: readDiscoveryLastScannedAt() ?? null,
+			classifications,
+			discoveryLastScannedAt: readDiscoveryLastScannedAt(),
 			scopedNote
-		};
+		});
 	} catch (err) {
 		let message;
 		try {
@@ -576,6 +657,9 @@ const runTestsBody = async (input, ctx) => {
 		try {
 			await vitest?.close();
 		} finally {
+			try {
+				if (previousCwd !== void 0) process.chdir(previousCwd);
+			} catch {}
 			nullStream.destroy();
 			if (covOverride !== void 0) try {
 				rmSync(covOverride.dir, {
@@ -606,7 +690,7 @@ const handleRunTests = (input) => Effect.gen(function* () {
 		runPromise: (effect) => Effect.runPromise(Effect.provideContext(effect, services)),
 		runFork: makeBestEffortFork(services)
 	};
-	return yield* Semaphore.withPermit(runTestsSemaphore, Effect.promise(() => runTestsBody(input, ctx)));
+	return yield* Semaphore.withPermit(runTestsSemaphore, Effect.uninterruptible(Effect.promise(() => runTestsBody(input, ctx))));
 });
 /**
 * The Effect-native `run_tests` tool.
@@ -614,7 +698,7 @@ const handleRunTests = (input) => Effect.gen(function* () {
 * @public
 */
 const runTestsTool = Tool.make("run_tests", {
-	description: "Use to run Vitest tests, with optional file, project, and tag filters. structuredContent carries the typed AgentReport plus per-test classifications (discriminate on `kind`: ok, timeout, error, no-match). Unknown parameters are rejected — accepted keys are files, project, tags, passWithNoTests, timeout, projectRoot. When projectRoot is omitted, the server anchors the Vitest root at the directory of the vitest (or vite) config Vitest would load anyway, walking up from its boot dir and stopping at the git root — so a server booted inside a package subtree still resolves the root config's relative globalSetup/setupFiles correctly. projectRoot overrides that for this call and is used verbatim, but only after validation: it must be an existing directory belonging to the same git repository as ctx.cwd (checked via `git rev-parse --git-common-dir`, which is identical across a repo and all its worktrees, including a sibling worktree checked out from the same repo). A path in a different repository, or a non-existent path, is rejected with `{ kind: \"error\" }` naming both paths — never a silent fallback to ctx.cwd. The resolved root actually used is always echoed back on success. The legacy format=json arg is dropped — structuredContent supersedes it.",
+	description: "Use to run Vitest tests, with optional file, project, and tag filters. structuredContent carries the typed AgentReport plus per-test classifications (discriminate on `kind`: ok, timeout, error, no-match). Unknown parameters are rejected — accepted keys are files, project, tags, passWithNoTests, timeout, projectRoot. When projectRoot is omitted, the server anchors the Vitest root at the directory of the vitest (or vite) config Vitest would load anyway, walking up from its boot dir and stopping at the git root — so a server booted inside a package subtree still resolves the root config's relative globalSetup/setupFiles correctly. projectRoot overrides that for this call and is used verbatim, but only after validation: it must be an existing directory belonging to the same git repository as ctx.cwd (checked via `git rev-parse --path-format=absolute --git-common-dir`, which needs git 2.31 or newer and is identical across a repo and all its worktrees, including a sibling worktree checked out from the same repo). A path in a different repository, or a non-existent path, is rejected with `{ kind: \"error\" }` naming both paths — never a silent fallback to ctx.cwd. The resolved root actually used is always echoed back on success. The legacy format=json arg is dropped — structuredContent supersedes it.",
 	parameters: RunTestsInput,
 	success: RunTestsResult,
 	dependencies: [
@@ -625,4 +709,4 @@ const runTestsTool = Tool.make("run_tests", {
 }).annotate(Tool.Title, "Run tests").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, false);
 
 //#endregion
-export { RunTestsInput, RunTestsResult, coerceErrors, composeTagExpression, handleRunTests, makeBestEffortFork, makeCoverageDirOverride, readDiscoveryLastScannedAt, resolveAnchoredConfigFile, resolveConfigAnchoredRoot, resolveGitCommonDir, resolveVitestNodeEntry, runTestsTool, sanitizeTestArgs, validateProjectRoot, vitestLoader, withStdioCaptured };
+export { RunTestsInput, RunTestsResult, coerceErrors, composeTagExpression, deriveRunScope, handleRunTests, isNoMatch, makeBestEffortFork, makeCoverageDirOverride, readDiscoveryLastScannedAt, resolveAnchoredConfigFile, resolveConfigAnchoredRoot, resolveVitestNodeEntry, runTestsSemaphore, runTestsTool, sanitizeTestArgs, staleInstallMessage, toNoMatch, toOkPayload, validateProjectRoot, vitestLoader, withStdioCaptured };

package/version.js

@@ -7,7 +7,7 @@
 *
 * @public
 */
-const CURRENT_MCP_VERSION = "5.1.1";
+const CURRENT_MCP_VERSION = "5.1.2";
 
 //#endregion
 export { CURRENT_MCP_VERSION };