@vitest-agent/mcp 2.4.15 → 3.0.0

package/index.d.ts

@@ -213,6 +213,12 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
             readonly functions?: number | undefined;
             readonly branches?: number | undefined;
             readonly statements?: number | undefined;
+            readonly perFile?: boolean | {
+              readonly lines?: number | undefined;
+              readonly functions?: number | undefined;
+              readonly branches?: number | undefined;
+              readonly statements?: number | undefined;
+            };
           }])[];
         };
         readonly targets?: {
@@ -227,6 +233,12 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
             readonly functions?: number | undefined;
             readonly branches?: number | undefined;
             readonly statements?: number | undefined;
+            readonly perFile?: boolean | {
+              readonly lines?: number | undefined;
+              readonly functions?: number | undefined;
+              readonly branches?: number | undefined;
+              readonly statements?: number | undefined;
+            };
           }])[];
         } | undefined;
         readonly baselines?: {
@@ -241,6 +253,12 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
             readonly functions?: number | undefined;
             readonly branches?: number | undefined;
             readonly statements?: number | undefined;
+            readonly perFile?: boolean | {
+              readonly lines?: number | undefined;
+              readonly functions?: number | undefined;
+              readonly branches?: number | undefined;
+              readonly statements?: number | undefined;
+            };
           }])[];
         } | undefined;
         readonly scoped: boolean;
@@ -377,6 +395,15 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
         readonly scope: "module" | "suite" | "test" | "unhandled";
         readonly testFullName: string | null;
         readonly moduleFile: string | null;
+        readonly annotations: readonly {
+          readonly type: string;
+          readonly message: string;
+          readonly location?: {
+            readonly file: string;
+            readonly line: number;
+            readonly column: number;
+          } | undefined;
+        }[];
       }[];
     };
     meta: object;
@@ -400,6 +427,18 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
       readonly action: "for_tag";
       readonly tag: string;
       readonly project?: string | undefined;
+    } | {
+      readonly action: "annotations";
+      readonly fullName: string;
+      readonly project?: string | undefined;
+      readonly modulePath?: string | undefined;
+      readonly maxBytes?: number | undefined;
+    } | {
+      readonly action: "artifacts";
+      readonly fullName: string;
+      readonly project?: string | undefined;
+      readonly modulePath?: string | undefined;
+      readonly maxBytes?: number | undefined;
     };
     output: {
       readonly action: "list";
@@ -464,6 +503,51 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
           readonly classification: string | null;
         }[];
       }[];
+    } | {
+      readonly action: "annotations";
+      readonly project: string;
+      readonly fullName: string;
+      readonly count: number;
+      readonly annotations: readonly {
+        readonly id: number;
+        readonly type: string;
+        readonly message: string;
+        readonly location?: {
+          readonly file: string;
+          readonly line: number;
+          readonly column: number;
+        } | undefined;
+        readonly attachments: readonly {
+          readonly contentType?: string | undefined;
+          readonly path?: string | undefined;
+          readonly byteSize: number | null;
+          readonly body?: string | undefined;
+          readonly bodyEncoding?: "base64" | "utf-8" | undefined;
+        }[];
+      }[];
+    } | {
+      readonly action: "artifacts";
+      readonly project: string;
+      readonly fullName: string;
+      readonly count: number;
+      readonly artifacts: readonly {
+        readonly id: number;
+        readonly type: string;
+        readonly message: string | null;
+        readonly data: string | null;
+        readonly location?: {
+          readonly file: string;
+          readonly line: number;
+          readonly column: number;
+        } | undefined;
+        readonly attachments: readonly {
+          readonly contentType?: string | undefined;
+          readonly path?: string | undefined;
+          readonly byteSize: number | null;
+          readonly body?: string | undefined;
+          readonly bodyEncoding?: "base64" | "utf-8" | undefined;
+        }[];
+      }[];
     };
     meta: object;
   }>;
@@ -608,6 +692,12 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
               readonly functions?: number | undefined;
               readonly branches?: number | undefined;
               readonly statements?: number | undefined;
+              readonly perFile?: boolean | {
+                readonly lines?: number | undefined;
+                readonly functions?: number | undefined;
+                readonly branches?: number | undefined;
+                readonly statements?: number | undefined;
+              };
             }])[];
           };
           readonly targets?: {
@@ -622,6 +712,12 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
               readonly functions?: number | undefined;
               readonly branches?: number | undefined;
               readonly statements?: number | undefined;
+              readonly perFile?: boolean | {
+                readonly lines?: number | undefined;
+                readonly functions?: number | undefined;
+                readonly branches?: number | undefined;
+                readonly statements?: number | undefined;
+              };
             }])[];
           } | undefined;
           readonly baselines?: {
@@ -636,6 +732,12 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
               readonly functions?: number | undefined;
               readonly branches?: number | undefined;
               readonly statements?: number | undefined;
+              readonly perFile?: boolean | {
+                readonly lines?: number | undefined;
+                readonly functions?: number | undefined;
+                readonly branches?: number | undefined;
+                readonly statements?: number | undefined;
+              };
             }])[];
           } | undefined;
           readonly scoped: boolean;

package/index.js

@@ -12,7 +12,7 @@ import { parseSessionEnvExports, recoverSessionContextFromSessionEnv } from "./s
 *
 * @public
 */
-const CURRENT_MCP_VERSION = "2.4.15";
+const CURRENT_MCP_VERSION = "3.0.0";
 
 //#endregion
 export { CURRENT_MCP_VERSION, McpLive, appRouter, buildMcpServer, createCallerFactory, createCurrentSessionIdRef, createSessionContextRef, parseSessionEnvExports, recoverSessionContextFromSessionEnv, startMcpServer };

package/layers/McpLive.js

@@ -2,7 +2,7 @@ import { Layer } from "effect";
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { layer } from "@effect/sql-sqlite-node/SqliteClient";
 import * as SqliteMigrator from "@effect/sql-sqlite-node/SqliteMigrator";
-import { DataReaderLive, DataStoreLive, LoggerLive, OutputPipelineLive, ProjectDiscoveryLive, migration0001 } from "@vitest-agent/sdk";
+import { DataReaderLive, DataStoreLive, LoggerLive, OutputPipelineLive, PROJECT_MIGRATIONS, ProjectDiscoveryLive } from "@vitest-agent/sdk";
 
 //#region src/layers/McpLive.ts
 /**
@@ -21,7 +21,7 @@ import { DataReaderLive, DataStoreLive, LoggerLive, OutputPipelineLive, ProjectD
 const McpLive = (dbPath, logLevel, logFile) => {
 	const SqliteLayer = layer({ filename: dbPath });
 	const PlatformLayer = NodeServices.layer;
-	const MigratorLayer = SqliteMigrator.layer({ loader: SqliteMigrator.fromRecord({ "0001_initial": migration0001 }) }).pipe(Layer.provide(Layer.merge(SqliteLayer, PlatformLayer)));
+	const MigratorLayer = SqliteMigrator.layer({ loader: SqliteMigrator.fromRecord(PROJECT_MIGRATIONS) }).pipe(Layer.provide(Layer.merge(SqliteLayer, PlatformLayer)));
 	return Layer.mergeAll(DataReaderLive, DataStoreLive, ProjectDiscoveryLive, OutputPipelineLive).pipe(Layer.provideMerge(MigratorLayer), Layer.provideMerge(SqliteLayer), Layer.provideMerge(PlatformLayer), Layer.provideMerge(LoggerLive(logLevel, logFile)));
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/mcp",
-	"version": "2.4.15",
+	"version": "3.0.0",
 	"private": false,
 	"description": "Model Context Protocol server for vitest-agent. Exposes 53 tools for agent access to test data, TDD lifecycle, and session management.",
 	"keywords": [
@@ -42,12 +42,12 @@
 		"@effect/sql-sqlite-node": "4.0.0-rc.112",
 		"@modelcontextprotocol/sdk": "^1.30.0",
 		"@trpc/server": "^11.18.0",
-		"@vitest-agent/sdk": "2.5.1",
+		"@vitest-agent/sdk": "3.0.0",
 		"effect": "4.0.0-rc.112",
 		"zod": "^4.5.4"
 	},
 	"peerDependencies": {
-		"vitest": "^4.1.0"
+		"vitest": "^5.0.0"
 	},
 	"engines": {
 		"node": ">=24.11.0"

package/server.js

@@ -259,17 +259,18 @@ function buildMcpServer(ctx) {
 		return structuredResult(Schema.decodeSync(TestErrorsAsMarkdown)(data), data);
 	});
 	server.registerTool("test", {
-		description: "Use to inspect tests, with an action discriminator: action='list' (project?, state?, module?, limit?) returns matching tests; action='get' (fullName, project?, modulePath?) returns details + errors + run history — a fullName that exists in more than one module returns found=false with ambiguous=true and candidateModules[], so pass modulePath to disambiguate; action='for_file' (filePath) returns test modules covering a source file; action='for_tag' (tag, project?) returns tests carrying a tag, grouped by project. structuredContent carries the typed payload (discriminate on `action`, then on `found` for get).",
+		description: "Use to inspect tests, with an action discriminator: action='list' (project?, state?, module?, limit?) returns matching tests; action='get' (fullName, project?, modulePath?) returns details + errors + run history — a fullName that exists in more than one module returns found=false with ambiguous=true and candidateModules[], so pass modulePath to disambiguate; action='for_file' (filePath) returns test modules covering a source file; action='for_tag' (tag, project?) returns tests carrying a tag, grouped by project; action='annotations' (fullName, project?, modulePath?) returns the test annotations the author recorded via context.annotate; action='artifacts' (fullName, project?, modulePath?) returns the test artifacts recorded for the test — both return attachment descriptors (contentType, path, byteSize) and omit inline bodies unless maxBytes (a non-negative integer byte budget for the whole response, default 0) is passed, and neither has anything to do with TDD artifacts (see tdd_artifact_list). structuredContent carries the typed payload (discriminate on `action`, then on `found` for get).",
 		inputSchema: strict({
 			action: z.enum(TEST_ACTIONS).describe("Inspection discriminator"),
 			project: z.optional(z.string()),
 			state: z.optional(z.string()).describe("list: filter by state"),
 			module: z.optional(z.string()).describe("list: filter by module path"),
 			limit: z.optional(z.coerce.number()).describe("list: max rows to return"),
-			fullName: z.optional(z.string()).describe("get: full test name"),
-			modulePath: z.optional(z.string()).describe("get: exact module path, disambiguating a fullName present in several files"),
+			fullName: z.optional(z.string()).describe("get / annotations / artifacts: full test name"),
+			modulePath: z.optional(z.string()).describe("get / annotations / artifacts: exact module path, disambiguating a fullName present in several files"),
 			filePath: z.optional(z.string()).describe("for_file: source file path"),
-			tag: z.optional(z.string()).describe("for_tag: tag name")
+			tag: z.optional(z.string()).describe("for_tag: tag name"),
+			maxBytes: z.optional(z.coerce.number().int().nonnegative()).describe("annotations / artifacts: total byte budget for inline attachment bodies across the response; default 0 returns descriptors only")
 		}),
 		outputSchema: effectToZodSchema(TestResult)
 	}, async (args) => {
@@ -291,6 +292,20 @@ function buildMcpServer(ctx) {
 			action: "for_file",
 			filePath: args.filePath
 		});
+		else if (args.action === "annotations") data = await caller.test({
+			action: "annotations",
+			fullName: args.fullName,
+			...args.project !== void 0 && { project: args.project },
+			...args.modulePath !== void 0 && { modulePath: args.modulePath },
+			...args.maxBytes !== void 0 && { maxBytes: args.maxBytes }
+		});
+		else if (args.action === "artifacts") data = await caller.test({
+			action: "artifacts",
+			fullName: args.fullName,
+			...args.project !== void 0 && { project: args.project },
+			...args.modulePath !== void 0 && { modulePath: args.modulePath },
+			...args.maxBytes !== void 0 && { maxBytes: args.maxBytes }
+		});
 		else data = await caller.test({
 			action: "for_tag",
 			tag: args.tag,

package/tools/errors.js

@@ -20,6 +20,16 @@ import { DataReader } from "@vitest-agent/sdk";
 *
 * @packageDocumentation
 */
+/** One annotation attached to a failing test, surfaced with its error. */
+const TestErrorAnnotation = Schema.Struct({
+	type: Schema.String.annotate({ description: "Annotation type as the test author wrote it — an arbitrary string, not an enum." }),
+	message: Schema.String,
+	location: Schema.optional(Schema.Struct({
+		file: Schema.String,
+		line: Schema.Number,
+		column: Schema.Number
+	}))
+}).annotate({ identifier: "TestErrorAnnotation" });
 /** One row in the structured `errors[]` array. */
 const TestErrorRow = Schema.Struct({
 	id: Schema.Finite.annotate({
@@ -43,7 +53,8 @@ const TestErrorRow = Schema.Struct({
 		"unhandled"
 	]).annotate({ description: "Where the error fired: `test` (a single test case), `suite` (a `describe` setup), `module` (collection / import time), or `unhandled` (uncaught from a background context)." }),
 	testFullName: Schema.NullOr(Schema.String).annotate({ description: "Full hierarchical test name (`describe > it`); `null` for non-test scopes (`module`, `unhandled`)." }),
-	moduleFile: Schema.NullOr(Schema.String).annotate({ description: "Repo-relative path of the test module the error originated in." })
+	moduleFile: Schema.NullOr(Schema.String).annotate({ description: "Repo-relative path of the test module the error originated in." }),
+	annotations: Schema.Array(TestErrorAnnotation).annotate({ description: "Test annotations the author recorded on this test (`context.annotate`). Empty for non-test scopes and for tests with no annotations." })
 }).annotate({
 	identifier: "TestErrorRow",
 	title: "Test error row",
@@ -87,6 +98,10 @@ const formatTestErrorsMarkdown = (data) => {
 		lines.push(`**Scope:** ${error.scope}`);
 		if (error.testFullName !== null) lines.push(`**Test:** ${error.testFullName}`);
 		if (error.moduleFile !== null) lines.push(`**File:** \`${error.moduleFile}\``);
+		if (error.annotations.length > 0) {
+			lines.push("**Annotations:**");
+			for (const annotation of error.annotations) lines.push(`- [${annotation.type}] ${annotation.message}`);
+		}
 		lines.push("");
 		lines.push("**Cite-able IDs (for `hypothesis (action: record)`):**");
 		lines.push(`- citedTestErrorId: ${error.id}`);
@@ -142,14 +157,40 @@ const testErrors = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct
 	project: Schema.String,
 	errorName: Schema.optional(Schema.String)
 }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
-	const errors = yield* (yield* DataReader).getErrors(input.project, input.errorName);
+	const reader = yield* DataReader;
+	const errors = yield* reader.getErrors(input.project, input.errorName);
+	const cache = /* @__PURE__ */ new Map();
+	const rows = [];
+	for (const error of errors) {
+		if (error.testFullName === null) {
+			rows.push({
+				...error,
+				annotations: []
+			});
+			continue;
+		}
+		const key = `${error.testFullName}\u0000${error.moduleFile ?? ""}`;
+		let annotations = cache.get(key);
+		if (annotations === void 0) {
+			annotations = (yield* reader.getAnnotationsForTest(input.project, error.testFullName, { ...error.moduleFile !== null && { modulePath: error.moduleFile } })).map((a) => ({
+				type: a.type,
+				message: a.message,
+				...a.location && { location: a.location }
+			}));
+			cache.set(key, annotations);
+		}
+		rows.push({
+			...error,
+			annotations
+		});
+	}
 	return {
 		project: input.project,
 		...input.errorName !== void 0 && { errorName: input.errorName },
-		count: errors.length,
-		errors
+		count: rows.length,
+		errors: rows
 	};
 })));
 
 //#endregion
-export { TestErrorRow, TestErrorsAsMarkdown, TestErrorsResult, formatTestErrorsMarkdown, testErrors };
+export { TestErrorAnnotation, TestErrorRow, TestErrorsAsMarkdown, TestErrorsResult, formatTestErrorsMarkdown, testErrors };

package/tools/help.js

@@ -31,14 +31,17 @@ const HELP_TEXT = `# vitest-agent MCP Tools
 | \`file_coverage\` | \`filePath\`, \`project?\` | Per-file coverage with uncovered lines and related tests |
 | \`test_history\` | \`project\` | Flaky/persistent/recovered tests |
 | \`test_trends\` | \`project\`, \`limit?\` | Coverage trajectory over time |
-| \`test_errors\` | \`project\`, \`errorName?\`, \`format?\` (\`markdown\` \\| \`xml\`) | Errors with diffs, stacks, and the cite-able \`testErrorId\` / \`topStackFrameId\` values needed by \`hypothesis (action: record)\` |
-| \`test\` | \`action\` (\`list\`/\`get\`/\`for_file\`/\`for_tag\`), plus per-action params | Consolidated test inspection: list/get/for_file/for_tag |
+| \`test_errors\` | \`project\`, \`errorName?\`, \`format?\` (\`markdown\` \\| \`xml\`) | Errors with diffs, stacks, each row's \`annotations[]\` (the test annotations the author recorded), and the cite-able \`testErrorId\` / \`topStackFrameId\` values needed by \`hypothesis (action: record)\` |
+| \`test\` | \`action\` (\`list\`/\`get\`/\`for_file\`/\`for_tag\`/\`annotations\`/\`artifacts\`), plus per-action params | Consolidated test inspection: list/get/for_file/for_tag/annotations/artifacts |
 
 \`test\` actions:
 - \`{ action: "list", project?, state?, module?, limit? }\`
 - \`{ action: "get", fullName, project?, modulePath? }\` — a \`fullName\` present in more than one module returns \`found: false\` with \`ambiguous: true\` and \`candidateModules[]\`; pass \`modulePath\` to pick one
 - \`{ action: "for_file", filePath }\`
 - \`{ action: "for_tag", tag, project? }\` — list every test carrying a tag, grouped by project (or one group when project is supplied)
+- \`{ action: "annotations", fullName, project?, modulePath?, maxBytes? }\` — the test annotations the author recorded via \`context.annotate\`, with attachment descriptors (\`contentType\`, \`path\`, \`byteSize\`)
+- \`{ action: "artifacts", fullName, project?, modulePath?, maxBytes? }\` — the test artifacts recorded for the test, same descriptor shape. These are Vitest test artifacts, not TDD artifacts
+- \`maxBytes\` (both actions) is the total byte budget for inline attachment bodies across the response; it defaults to 0, so a \`body\` is returned only when you ask for one and the running total stays inside the budget
 
 ## Discovery
 
@@ -107,7 +110,7 @@ const HELP_TEXT = `# vitest-agent MCP Tools
 | \`tdd_task\` | \`action\` (\`start\`/\`end\`/\`get\`/\`resume\`), plus per-action params | TDD task lifecycle |
 | \`tdd_goal\` | \`action\` (\`create\`/\`update\`/\`delete\`/\`get\`/\`list\`), plus per-action params | Goals under a TDD task |
 | \`tdd_behavior\` | \`action\` (\`create\`/\`update\`/\`delete\`/\`get\`/\`list_by_goal\`/\`list_by_tdd_task\`), plus per-action params | Behaviors under a goal |
-| \`tdd_artifact_list\` | \`tddTaskId\`, \`artifactKind?\`, \`phaseId?\`, \`behaviorId?\`, \`limit?\`, \`format?\` | List recorded TDD artifacts (newest first); use to find the artifact id to cite in \`tdd_phase_transition_request\` |
+| \`tdd_artifact_list\` | \`tddTaskId\`, \`artifactKind?\`, \`phaseId?\`, \`behaviorId?\`, \`limit?\`, \`format?\` | List recorded TDD artifacts (newest first); use to find the artifact id to cite in \`tdd_phase_transition_request\`. TDD artifacts are red/green evidence rows, not Vitest test artifacts (see \`test\` action \`artifacts\`) |
 | \`tdd_phase_transition_request\` | \`tddTaskId\`, \`goalId\`, \`requestedPhase\`, \`citedArtifactId?\`, \`citedArtifactKind?\`, \`behaviorId?\`, \`reason?\` | Request a phase transition; validates D2 binding rules. \`citedArtifactId\` is optional — when omitted, the most recent matching artifact (kind from \`citedArtifactKind\` or the transition's required-evidence rule) is auto-resolved |
 | \`tdd_progress_push\` | \`payload\` | Push a TDD progress event to the main agent (best-effort) |
 

package/tools/run-tests.js

@@ -209,9 +209,38 @@ 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;
+}
 function dirHasVitestOrViteConfig(dir) {
-	for (const prefix of ["vitest.config.", "vite.config."]) for (const ext of VITEST_CONFIG_EXTENSIONS) if (existsSync(join(dir, `${prefix}${ext}`))) return true;
-	return false;
+	return findConfigInDir(dir) !== null;
+}
+/**
+* Walk UP from `startDir` looking for the vitest/vite config file, returning
+* its absolute path. Same walk and same git-root bound as
+* `resolveConfigAnchoredRoot`; returns `null` when no config is found in
+* range or when anything about the walk throws.
+*
+* @internal exported for tests
+*/
+function resolveAnchoredConfigFile(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;
+	}
 }
 /**
 * Walk UP from `startDir` looking for the vitest/vite config Vitest would
@@ -245,11 +274,14 @@ function resolveConfigAnchoredRoot(startDir) {
 * defaulted to anything else when no config is found in range.
 *
 * A supplied `projectRoot` is VALIDATED, not trusted, and used VERBATIM
-* once validated — explicit is explicit, no anchoring applied. It must
-* resolve to an existing directory that shares a git common directory with
-* `ctxCwd` (same repository, including across worktrees). Any failure
-* returns `{ ok: false, message }` naming both paths — never a silent
-* fallback to `ctxCwd`, never a raw throw.
+* once validated — explicit is explicit, no anchoring applied to `root`.
+* It must resolve to an existing directory that shares a git common
+* directory with `ctxCwd` (same repository, including across worktrees).
+* Any failure returns `{ ok: false, message }` naming both paths — never a
+* silent fallback to `ctxCwd`, never a raw throw. The CONFIG for such a
+* root is resolved separately by the caller via
+* `resolveAnchoredConfigFile`, because Vitest 5 no longer walks up to find
+* one.
 *
 * @internal exported for tests
 */
@@ -288,8 +320,8 @@ async function validateProjectRoot(projectRoot, ctxCwd) {
 * `@vitest-agent/mcp`'s OWN install location. `vitest` is a peerDependency
 * of this package, and pnpm routinely materializes MORE THAN ONE physical
 * instance of the same vitest version when peer-resolution hashes differ
-* (e.g. `vitest@4.1.11_@types+node@26.2.0_...` alongside
-* `vitest@4.1.11_@types+node@26.3.0_...` under `node_modules/.pnpm`). When
+* (e.g. `vitest@<version>_@types+node@26.2.0_...` alongside
+* `vitest@<version>_@types+node@26.3.0_...` under `node_modules/.pnpm`). When
 * the bare specifier resolves to a DIFFERENT physical copy than the one the
 * project's test files import, `SnapshotClient.setup()` runs against one
 * copy's module-level `_client` singleton while `expect(...).toMatchSnapshot()`
@@ -508,6 +540,15 @@ const runTests = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({
 		message: projectRootValidation.message
 	};
 	const resolvedRoot = projectRootValidation.root;
+	let anchoredConfig;
+	if (input.projectRoot !== void 0) {
+		const found = 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 timeoutMs = (input.timeout ?? 120) * 1e3;
 	const recovered = input._sessionContext ?? null ?? ctx.sessionContext.get();
 	if (recovered !== null) {
@@ -523,8 +564,9 @@ const runTests = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({
 	let covOverride;
 	try {
 		covOverride = makeCoverageDirOverride();
-		vitest = await createVitest("test", {
+		vitest = await createVitest({
 			root: resolvedRoot,
+			...anchoredConfig !== void 0 ? { config: anchoredConfig } : {},
 			run: true,
 			coverage: covOverride.coverage,
 			...project ? { project } : {},
@@ -640,4 +682,4 @@ const runTests = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({
 }));
 
 //#endregion
-export { RunTestsAsMarkdown, RunTestsResult, coerceErrors, composeTagExpression, formatNoMatchMarkdown, formatReportMarkdown, formatRunTestsMarkdown, makeCoverageDirOverride, readDiscoveryLastScannedAt, resolveConfigAnchoredRoot, resolveGitCommonDir, resolveVitestNodeEntry, runTests, sanitizeTestArgs, validateProjectRoot, vitestLoader, withStdioCaptured };
+export { RunTestsAsMarkdown, RunTestsResult, coerceErrors, composeTagExpression, formatNoMatchMarkdown, formatReportMarkdown, formatRunTestsMarkdown, makeCoverageDirOverride, readDiscoveryLastScannedAt, resolveAnchoredConfigFile, resolveConfigAnchoredRoot, resolveGitCommonDir, resolveVitestNodeEntry, runTests, sanitizeTestArgs, validateProjectRoot, vitestLoader, withStdioCaptured };

package/tools/test.js

@@ -4,16 +4,6 @@ import { Effect, Match, Option, Schema, SchemaGetter } from "effect";
 import { DataReader } from "@vitest-agent/sdk";
 
 //#region src/tools/test.ts
-/**
-* Consolidated `test` MCP tool — Schema-driven implementation.
-*
-* Replaces `test_list`, `test_get`, and `test_for_file` with one
-* tool keyed on `action`. Result variants discriminate on
-* `inventoryKind` so a single Effect Schema describes every shape
-* the tool can emit.
-*
-* @packageDocumentation
-*/
 const TestRowSchema = Schema.Struct({
 	id: Schema.Number,
 	fullName: Schema.String,
@@ -76,16 +66,93 @@ const TestForTagResult = Schema.Struct({
 	count: Schema.Number,
 	groups: Schema.Array(TestListGroup)
 }).annotate({ identifier: "TestForTag" });
+const AttachmentDescriptor = Schema.Struct({
+	contentType: Schema.optional(Schema.String),
+	path: Schema.optional(Schema.String),
+	byteSize: Schema.NullOr(Schema.Number),
+	/** Present only for inline attachments under the 64 KiB persistence cap. */
+	body: Schema.optional(Schema.String),
+	/** How to read `body`. Absent when nothing was stored inline. */
+	bodyEncoding: Schema.optional(Schema.Literals(["base64", "utf-8"]))
+}).annotate({ identifier: "TestAttachmentDescriptor" });
+/**
+* Inline bodies are opt-in and budgeted. The 64 KiB persistence cap is
+* per attachment, so a test with many attachments could still flood an
+* agent's context; `maxBytes` (default 0) is the total byte budget for
+* every body in one response. Attachments are walked in order and each
+* body is charged its recorded `byteSize` (falling back to the stored
+* string's length when the row carries none). A body that would take
+* the running total past the budget is dropped along with its
+* `bodyEncoding`; the descriptor half — `contentType`, `path`,
+* `byteSize` — always survives.
+*/
+const applyBodyBudget = (rows, maxBytes) => {
+	let spent = 0;
+	return rows.map((row) => ({
+		...row,
+		attachments: row.attachments.map((attachment) => {
+			const { body, bodyEncoding, ...descriptor } = attachment;
+			if (body === void 0) return descriptor;
+			const cost = attachment.byteSize ?? body.length;
+			if (spent + cost > maxBytes) return descriptor;
+			spent += cost;
+			return {
+				...descriptor,
+				body,
+				...bodyEncoding !== void 0 && { bodyEncoding }
+			};
+		})
+	}));
+};
+const AnnotationRowSchema = Schema.Struct({
+	id: Schema.Number,
+	type: Schema.String,
+	message: Schema.String,
+	location: Schema.optional(Schema.Struct({
+		file: Schema.String,
+		line: Schema.Number,
+		column: Schema.Number
+	})),
+	attachments: Schema.Array(AttachmentDescriptor)
+}).annotate({ identifier: "TestAnnotationRow" });
+const ArtifactRowSchema = Schema.Struct({
+	id: Schema.Number,
+	type: Schema.String,
+	message: Schema.NullOr(Schema.String),
+	data: Schema.NullOr(Schema.String),
+	location: Schema.optional(Schema.Struct({
+		file: Schema.String,
+		line: Schema.Number,
+		column: Schema.Number
+	})),
+	attachments: Schema.Array(AttachmentDescriptor)
+}).annotate({ identifier: "TestArtifactRow" });
+const TestAnnotationsResult = Schema.Struct({
+	action: Schema.Literal("annotations"),
+	project: Schema.String,
+	fullName: Schema.String,
+	count: Schema.Number,
+	annotations: Schema.Array(AnnotationRowSchema)
+}).annotate({ identifier: "TestAnnotations" });
+const TestArtifactsResult = Schema.Struct({
+	action: Schema.Literal("artifacts"),
+	project: Schema.String,
+	fullName: Schema.String,
+	count: Schema.Number,
+	artifacts: Schema.Array(ArtifactRowSchema)
+}).annotate({ identifier: "TestArtifacts" });
 const TestResult = Schema.Union([
 	TestListResult,
 	TestGetFound,
 	TestGetMissing,
 	TestForFileResult,
-	TestForTagResult
+	TestForTagResult,
+	TestAnnotationsResult,
+	TestArtifactsResult
 ]).annotate({
 	identifier: "TestResult",
 	title: "test result",
-	description: "Discriminate on `action`. `get` further discriminates on `found`. `list`, `for_file`, and `for_tag` all carry counted arrays — `list` and `for_tag` group by project."
+	description: "Discriminate on `action`. `get` further discriminates on `found`. `list`, `for_file`, `for_tag`, `annotations`, and `artifacts` all carry counted arrays — `list` and `for_tag` group by project; `annotations` and `artifacts` are scoped to one test and return attachment descriptors — an inline `body` comes back only when `maxBytes` is passed and the running total stays inside it."
 });
 const formatTestMarkdown = (data) => {
 	if (data.action === "list") {
@@ -178,6 +245,42 @@ const formatTestMarkdown = (data) => {
 		}
 		return lines.join("\n").trimEnd();
 	}
+	if (data.action === "annotations" || data.action === "artifacts") {
+		const noun = data.action === "annotations" ? "test annotations" : "test artifacts";
+		if (data.count === 0) return `No ${noun} recorded for \`${data.fullName}\`.`;
+		const rows = data.action === "annotations" ? data.annotations.map((a) => ({
+			type: a.type,
+			message: a.message,
+			location: a.location,
+			attachments: a.attachments
+		})) : data.artifacts.map((a) => ({
+			type: a.type,
+			message: a.message ?? a.data,
+			location: a.location,
+			attachments: a.attachments
+		}));
+		const cell = (value) => {
+			const flat = value.split("\n").join(" ").split("|").join("\\|");
+			return flat.length > 200 ? `${flat.slice(0, 200)}… (truncated)` : flat;
+		};
+		const lines = [
+			`# ${data.action === "annotations" ? "Annotations" : "Artifacts"} for \`${data.fullName}\``,
+			"",
+			`Project: \`${data.project}\` — ${data.count} row${data.count === 1 ? "" : "s"}.`,
+			"",
+			"| Type | Message | Location | Attachments |",
+			"| --- | --- | --- | --- |"
+		];
+		for (const row of rows) {
+			const location = row.location ? `\`${row.location.file}:${row.location.line}:${row.location.column}\`` : "—";
+			const attachments = row.attachments.length === 0 ? "—" : row.attachments.map((att) => {
+				return `\`${cell(att.path ?? att.contentType ?? "(inline)")}\`${att.byteSize !== null ? ` (${att.byteSize} bytes)` : ""}`;
+			}).join(", ");
+			const message = row.message === null ? "—" : cell(row.message);
+			lines.push(`| ${row.type} | ${message} | ${location} | ${attachments} |`);
+		}
+		return lines.join("\n");
+	}
 	if (data.count === 0) return `No test modules found covering \`${data.filePath}\`. Run run_tests({}) to populate the database, or check the file path.`;
 	const lines = [
 		`# Tests for \`${data.filePath}\``,
@@ -214,11 +317,27 @@ const ForTagVariant = Schema.Struct({
 	tag: Schema.String,
 	project: Schema.optional(Schema.String)
 });
+const AnnotationsVariant = Schema.Struct({
+	action: Schema.Literal("annotations"),
+	fullName: Schema.String,
+	project: Schema.optional(Schema.String),
+	modulePath: Schema.optional(Schema.String).annotate({ description: "Exact module_path match — disambiguates a fullName that exists in more than one test file." }),
+	maxBytes: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)).annotate({ description: "Total byte budget for inline attachment bodies across the whole response. Must be a non-negative integer. Defaults to 0 — descriptors only, no bodies." }))
+});
+const ArtifactsVariant = Schema.Struct({
+	action: Schema.Literal("artifacts"),
+	fullName: Schema.String,
+	project: Schema.optional(Schema.String),
+	modulePath: Schema.optional(Schema.String).annotate({ description: "Exact module_path match — disambiguates a fullName that exists in more than one test file." }),
+	maxBytes: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)).annotate({ description: "Total byte budget for inline attachment bodies across the whole response. Must be a non-negative integer. Defaults to 0 — descriptors only, no bodies." }))
+});
 const TestInput = Schema.Union([
 	ListVariant,
 	GetVariant,
 	ForFileVariant,
-	ForTagVariant
+	ForTagVariant,
+	AnnotationsVariant,
+	ArtifactsVariant
 ]);
 /**
 * Single source of truth for the `test` tool's `action` discriminant,
@@ -229,7 +348,9 @@ const TEST_ACTIONS = [
 	"list",
 	"get",
 	"for_file",
-	"for_tag"
+	"for_tag",
+	"annotations",
+	"artifacts"
 ];
 const test = publicProcedure.input(Schema.toStandardSchemaV1(TestInput)).query(async ({ ctx, input }) => {
 	return ctx.runtime.runPromise(Match.value(input).pipe(Match.discriminatorsExhaustive("action")({
@@ -316,6 +437,32 @@ const test = publicProcedure.input(Schema.toStandardSchemaV1(TestInput)).query(a
 				count: grouped.total,
 				groups
 			};
+		}),
+		annotations: (variant) => Effect.gen(function* () {
+			const reader = yield* DataReader;
+			const project = variant.project ?? (yield* reader.getRunsByProject().pipe(Effect.map((rs) => rs[0]?.project ?? "")));
+			const rows = yield* reader.getAnnotationsForTest(project, variant.fullName, { ...variant.modulePath !== void 0 && { modulePath: variant.modulePath } });
+			const annotations = applyBodyBudget(rows, variant.maxBytes ?? 0);
+			return {
+				action: "annotations",
+				project,
+				fullName: variant.fullName,
+				count: annotations.length,
+				annotations
+			};
+		}),
+		artifacts: (variant) => Effect.gen(function* () {
+			const reader = yield* DataReader;
+			const project = variant.project ?? (yield* reader.getRunsByProject().pipe(Effect.map((rs) => rs[0]?.project ?? "")));
+			const rows = yield* reader.getArtifactsForTest(project, variant.fullName, { ...variant.modulePath !== void 0 && { modulePath: variant.modulePath } });
+			const artifacts = applyBodyBudget(rows, variant.maxBytes ?? 0);
+			return {
+				action: "artifacts",
+				project,
+				fullName: variant.fullName,
+				count: artifacts.length,
+				artifacts
+			};
 		})
 	})));
 });