@vitest-agent/mcp 1.0.0

package/index.js

@@ -0,0 +1,19 @@
+import { createCallerFactory, createCurrentSessionIdRef, createSessionContextRef } from "./context.js";
+import { McpLive } from "./layers/McpLive.js";
+import { appRouter } from "./router.js";
+import { startMcpServer } from "./server.js";
+
+//#region src/index.ts
+/**
+* The version of this package, inlined at build time from
+* package.json#version via rslib-builder's __PACKAGE_VERSION__ substitution.
+* Compared against CURRENT_SDK_VERSION at MCP bin init to surface
+* partially-upgraded installs as a single stderr warning. See the root
+* CLAUDE.md "Cross-package version drift" section.
+*
+* @public
+*/
+const CURRENT_MCP_VERSION = "1.0.0";
+
+//#endregion
+export { CURRENT_MCP_VERSION, McpLive, appRouter, createCallerFactory, createCurrentSessionIdRef, createSessionContextRef, startMcpServer };

package/layers/McpLive.js

@@ -0,0 +1,30 @@
+import { NodeFileSystem } from "@effect/platform-node";
+import * as NodeContext$1 from "@effect/platform-node/NodeContext";
+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 { Layer } from "effect";
+
+//#region src/layers/McpLive.ts
+/**
+* Builds the Effect Layer that provides all services required by the MCP server.
+*
+* Composes DataReader, DataStore, ProjectDiscovery, OutputPipeline, SQLite
+* client, migrator, NodeContext, NodeFileSystem, and the logger into a single
+* layer suitable for `ManagedRuntime.make`.
+*
+* @param dbPath - absolute path to the SQLite database file
+* @param logLevel - optional log level; defaults to the logger's own default
+* @param logFile - optional path to write structured log output
+* @returns an Effect Layer providing all MCP runtime services
+* @public
+*/
+const McpLive = (dbPath, logLevel, logFile) => {
+	const SqliteLayer = layer({ filename: dbPath });
+	const PlatformLayer = NodeContext$1.layer;
+	const MigratorLayer = SqliteMigrator.layer({ loader: SqliteMigrator.fromRecord({ "0001_initial": migration0001 }) }).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(NodeFileSystem.layer), Layer.provideMerge(LoggerLive(logLevel, logFile)));
+};
+
+//#endregion
+export { McpLive };

package/middleware/idempotency.js

@@ -0,0 +1,128 @@
+import { middleware, publicProcedure } from "../context.js";
+import { DataReader, DataStore } from "@vitest-agent/sdk";
+import { Effect, Option } from "effect";
+
+//#region src/middleware/idempotency.ts
+/**
+* Registered idempotency specs for mutation procedures.
+*
+* `hypothesis validate` is covered (key: `validate:${id}:${outcome}`).
+* `hypothesis record` is deliberately not covered — see the note in the
+* hypothesis spec below.
+*
+* Add an entry here whenever a new idempotent mutation is introduced.
+*/
+const idempotencyKeys = [
+	{
+		procedurePath: "hypothesis",
+		deriveKey: (input) => {
+			if (input === null || typeof input !== "object" || !("action" in input)) return null;
+			const i = input;
+			if (i.action === "validate" && typeof i.id === "number" && typeof i.outcome === "string") return `validate:${i.id}:${i.outcome}`;
+			return null;
+		}
+	},
+	{
+		procedurePath: "_legacy_hypothesis_validate",
+		deriveKey: (input) => {
+			if (input !== null && typeof input === "object" && "id" in input && "outcome" in input && typeof input.id === "number" && typeof input.outcome === "string") {
+				const i = input;
+				return `${i.id}:${i.outcome}`;
+			}
+			return null;
+		}
+	},
+	{
+		procedurePath: "tdd_task",
+		deriveKey: (input) => {
+			if (input === null || typeof input !== "object" || !("action" in input)) return null;
+			const i = input;
+			if (i.action === "start" && typeof i.goal === "string") {
+				if (typeof i.runId === "string") {
+					if (typeof i.sessionId === "number") return `start:sid:${i.sessionId}:run:${i.runId}`;
+					if (typeof i.chatId === "string") return `start:chat:${i.chatId}:run:${i.runId}`;
+				}
+				if (typeof i.sessionId === "number") return `start:sid:${i.sessionId}:${i.goal}`;
+				if (typeof i.chatId === "string") return `start:chat:${i.chatId}:${i.goal}`;
+			}
+			if (i.action === "end" && typeof i.tddTaskId === "number" && typeof i.outcome === "string") return `end:${i.tddTaskId}:${i.outcome}`;
+			return null;
+		}
+	},
+	{
+		procedurePath: "tdd_goal",
+		deriveKey: (input) => {
+			if (input === null || typeof input !== "object" || !("action" in input)) return null;
+			const i = input;
+			if (i.action === "create" && typeof i.tddTaskId === "number" && typeof i.goal === "string") return `create:${i.tddTaskId}:${i.goal}`;
+			return null;
+		}
+	},
+	{
+		procedurePath: "tdd_behavior",
+		deriveKey: (input) => {
+			if (input === null || typeof input !== "object" || !("action" in input)) return null;
+			const i = input;
+			if (i.action === "create" && typeof i.goalId === "number" && typeof i.behavior === "string") return `create:${i.goalId}:${i.behavior}`;
+			return null;
+		}
+	}
+];
+/** Lookup table keyed by procedure path for O(1) spec retrieval. */
+const keySpecByPath = new Map(idempotencyKeys.map((s) => [s.procedurePath, s]));
+/**
+* tRPC middleware that caches mutation results in `mcp_idempotent_responses`.
+*
+* On every mutation call where the procedure path has a registered
+* `IdempotencyKeySpec`:
+*
+* 1. Derive the idempotency key from the raw input.
+* 2. Look up `DataReader.findIdempotentResponse(path, key)`.
+*    - Cache HIT  → return the stored JSON result immediately (no handler).
+*    - Cache MISS → call `next()` to run the handler, then persist the result
+*      via `DataStore.recordIdempotentResponse`. Persistence errors are
+*      swallowed (best-effort) so a transient DB failure doesn't surface to
+*      the caller as a tool error.
+*
+* Procedures without a registered spec, or where key derivation returns
+* `null`, pass straight through to `next()` without any caching.
+*/
+const idempotent = middleware(async (opts) => {
+	const { ctx, path, type, getRawInput, next } = opts;
+	if (type !== "mutation") return next();
+	const spec = keySpecByPath.get(path);
+	if (!spec) return next();
+	const rawInput = await getRawInput();
+	const key = spec.deriveKey(rawInput);
+	if (key === null) return next();
+	const cached = await ctx.runtime.runPromise(Effect.gen(function* () {
+		return yield* (yield* DataReader).findIdempotentResponse(path, key);
+	}));
+	if (Option.isSome(cached)) {
+		const parsed = JSON.parse(cached.value);
+		return {
+			ok: true,
+			data: parsed !== null && typeof parsed === "object" ? {
+				...parsed,
+				_idempotentReplay: true
+			} : parsed,
+			marker: "middlewareMarker",
+			ctx
+		};
+	}
+	const result = await next();
+	if (result.ok) await ctx.runtime.runPromise(Effect.gen(function* () {
+		yield* (yield* DataStore).recordIdempotentResponse({
+			procedurePath: path,
+			key,
+			resultJson: JSON.stringify(result.data),
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	}).pipe(Effect.orElseSucceed(() => void 0)));
+	return result;
+});
+/** Drop-in replacement for `publicProcedure` on idempotent mutations. */
+const idempotentProcedure = publicProcedure.use(idempotent);
+
+//#endregion
+export { idempotentProcedure };

package/package.json

@@ -0,0 +1,58 @@
+{
+	"name": "@vitest-agent/mcp",
+	"version": "1.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": [
+		"vitest",
+		"agent",
+		"mcp",
+		"model-context-protocol",
+		"claude"
+	],
+	"homepage": "https://github.com/spencerbeggs/vitest-agent#readme",
+	"bugs": {
+		"url": "https://github.com/spencerbeggs/vitest-agent/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/spencerbeggs/vitest-agent.git",
+		"directory": "packages/mcp"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "C. Spencer Beggs",
+		"email": "spencer@beggs.codes",
+		"url": "https://spencerbeg.gs"
+	},
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./index.d.ts",
+			"import": "./index.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"bin": {
+		"vitest-agent-mcp": "bin/vitest-agent-mcp.js"
+	},
+	"dependencies": {
+		"@effect/cluster": "^0.59.0",
+		"@effect/platform": "^0.96.2",
+		"@effect/platform-node": "^0.107.0",
+		"@effect/rpc": "^0.75.1",
+		"@effect/sql": "^0.51.1",
+		"@effect/sql-sqlite-node": "^0.52.0",
+		"@modelcontextprotocol/sdk": "^1.29.0",
+		"@trpc/server": "^11.18.0",
+		"@vitest-agent/sdk": "1.0.0",
+		"effect": "^3.21.4",
+		"zod": "^4.4.3"
+	},
+	"peerDependencies": {
+		"vitest": "^4.1.0"
+	},
+	"engines": {
+		"node": ">=24.11.0"
+	}
+}

package/prompts/explain-failure.js

@@ -0,0 +1,27 @@
+//#region src/prompts/explain-failure.ts
+function explainFailurePrompt(args) {
+	return { messages: [{
+		role: "user",
+		content: {
+			type: "text",
+			text: [
+				`Explain the failure class identified by signature \`${args.signature}\`.`,
+				"",
+				"Steps:",
+				"",
+				`1. Call \`failure_signature_get\` with \`signature: "${args.signature}"\` to fetch the recurrence history (occurrence_count, first_seen_at, last_seen_at) and up to 10 recent test_errors with the same signature.`,
+				"2. Read the diffs and stack frames across the recent occurrences. The signature is stable across line shifts — same shape, possibly different line numbers — so recurrences are meaningful.",
+				"3. Distinguish:",
+				"   - **New instance of an old class** — the same kind of bug has appeared before; this occurrence adds to a known pattern.",
+				"   - **Fresh evidence** — the signature is recent (low occurrence_count, last_seen_at near first_seen_at) and represents a new bug class.",
+				"",
+				"Synthesize the root cause as a single explanation that accounts for every recent occurrence. If the occurrences disagree on root cause, the signature is too coarse — note this and flag the divergent occurrence ids.",
+				"",
+				"If a fix is obvious, record a hypothesis via `hypothesis_record` citing one of the test_error_ids as evidence. If a fix requires more investigation, note the missing data instead of guessing."
+			].join("\n")
+		}
+	}] };
+}
+
+//#endregion
+export { explainFailurePrompt };

package/prompts/index.js

@@ -0,0 +1,89 @@
+import { explainFailurePrompt } from "./explain-failure.js";
+import { regressionSincePassPrompt } from "./regression-since-pass.js";
+import { tddResumePrompt } from "./tdd-resume.js";
+import { triagePrompt } from "./triage.js";
+import { whyFlakyPrompt } from "./why-flaky.js";
+import { wrapupPrompt } from "./wrapup.js";
+import { z } from "zod";
+
+//#region src/prompts/index.ts
+function toMessages(messages) {
+	return messages.map((m) => ({
+		role: m.role,
+		content: {
+			type: "text",
+			text: m.content.text
+		}
+	}));
+}
+function registerAllPrompts(server) {
+	server.registerPrompt("triage", {
+		title: "Triage Recent Failures",
+		description: "Orient toward a triage workflow over the most recent test run; compose triage_brief, failure_signature_get, hypothesis_record.",
+		argsSchema: { project: z.optional(z.string()).describe("Filter to a specific project") }
+	}, (args) => {
+		return { messages: toMessages(triagePrompt(args.project !== void 0 ? { project: args.project } : {}).messages) };
+	});
+	server.registerPrompt("why-flaky", {
+		title: "Diagnose a Flaky Test",
+		description: "Diagnose why a named test is flaky; compose test_history and failure_signature_get with timing/shared-state framing.",
+		argsSchema: {
+			test: z.string().describe("Full hierarchical test name (e.g. 'Suite > nested > test')"),
+			project: z.optional(z.string()).describe("Filter to a specific project")
+		}
+	}, (args) => {
+		return { messages: toMessages(whyFlakyPrompt(args.project !== void 0 ? {
+			test: args.test,
+			project: args.project
+		} : { test: args.test }).messages) };
+	});
+	server.registerPrompt("regression-since-pass", {
+		title: "Find What Broke a Test",
+		description: "Walk back from the test's most recent passing run to identify the change that broke it; compose test_history, commit_changes, turn_search.",
+		argsSchema: {
+			test: z.string().describe("Full hierarchical test name"),
+			project: z.optional(z.string()).describe("Filter to a specific project")
+		}
+	}, (args) => {
+		return { messages: toMessages(regressionSincePassPrompt(args.project !== void 0 ? {
+			test: args.test,
+			project: args.project
+		} : { test: args.test }).messages) };
+	});
+	server.registerPrompt("explain-failure", {
+		title: "Explain a Failure Class",
+		description: "Synthesize a root-cause explanation from the recurrence history of a failure signature.",
+		argsSchema: { signature: z.string().describe("16-char failure signature hex") }
+	}, (args) => {
+		return { messages: toMessages(explainFailurePrompt({ signature: args.signature }).messages) };
+	});
+	server.registerPrompt("tdd-resume", {
+		title: "Resume TDD Work",
+		description: "Resume the active TDD task from its current phase; iron-law reminder for evidence-bound transitions.",
+		argsSchema: { sessionId: z.optional(z.string()).describe("Host session id (defaults to MCP server's recovered SessionContext)") }
+	}, (args) => {
+		return { messages: toMessages(tddResumePrompt(args.sessionId !== void 0 ? { sessionId: args.sessionId } : {}).messages) };
+	});
+	server.registerPrompt("wrapup", {
+		title: "Generate a Session Wrapup",
+		description: "Surface the same wrapup content the post-hooks emit automatically.",
+		argsSchema: {
+			kind: z.optional(z.enum([
+				"stop",
+				"session_end",
+				"pre_compact",
+				"tdd_handoff",
+				"user_prompt_nudge"
+			])).describe("Wrapup variant (default: user_prompt_nudge)"),
+			since: z.optional(z.string()).describe("ISO 8601 timestamp lower bound for activity to summarize")
+		}
+	}, (args) => {
+		const wrapupArgs = {};
+		if (args.kind !== void 0) wrapupArgs.kind = args.kind;
+		if (args.since !== void 0) wrapupArgs.since = args.since;
+		return { messages: toMessages(wrapupPrompt(wrapupArgs).messages) };
+	});
+}
+
+//#endregion
+export { registerAllPrompts };

package/prompts/regression-since-pass.js

@@ -0,0 +1,28 @@
+//#region src/prompts/regression-since-pass.ts
+function regressionSincePassPrompt(args) {
+	const projectClause = args.project ? ` in project \`${args.project}\`` : "";
+	return { messages: [{
+		role: "user",
+		content: {
+			type: "text",
+			text: [
+				`Identify what broke the test \`${args.test}\`${projectClause}.`,
+				"",
+				"The test passed at some point in recent history and now fails. The change that broke it lies in the window between then and now.",
+				"",
+				"Steps:",
+				"",
+				`1. Call \`test_history\` for ${args.project ? `\`project: "${args.project}"\` and ` : ""}the named test. Find the timestamp of the most recent passing run. Note the run id.`,
+				"2. Call `commit_changes` with no `sha` argument to fetch up to 20 most-recent commits. Filter to commits whose `committedAt` is later than the last passing run's timestamp.",
+				"3. Call `turn_search` for the same time window to see the agent activity (file_edits especially) between the last pass and the current fail.",
+				"4. Cross-reference the failing test's source / test files against the changed-files list. The cause is almost always in a file that appears in both.",
+				"5. Once you have a likely culprit, record a hypothesis via `hypothesis_record` citing the test_error_id and stack_frame_id of the most recent failure plus a short description of the change.",
+				"",
+				"If `turn_search` reveals the failing test was newly written in this window (no prior history), this is not a regression — it never passed. Treat it as a TDD-cycle failure instead."
+			].join("\n")
+		}
+	}] };
+}
+
+//#endregion
+export { regressionSincePassPrompt };

package/prompts/tdd-resume.js

@@ -0,0 +1,28 @@
+//#region src/prompts/tdd-resume.ts
+function tddResumePrompt(args) {
+	return { messages: [{
+		role: "user",
+		content: {
+			type: "text",
+			text: [
+				`Resume TDD work${args.sessionId ? ` for sessionId \`${args.sessionId}\`` : " for the active session (inferred from MCP server's recovered SessionContext)"}.`,
+				"",
+				"Steps:",
+				"",
+				`1. Call \`tdd_task({ action: "resume", id: <tdd-task-id> })\` to get the most recent open TDD task, including the current phase and the behavior backlog.`,
+				"2. The current phase determines what comes next:",
+				"   - **`spike` or `red.triangulate`** — write the next failing test for the current behavior.",
+				"   - **`red`** — run the test once to capture a `test_failed_run` artifact, then transition to `green`.",
+				"   - **`green`** — write the minimal source change to make the test pass; capture a `test_passed_run`; transition to `refactor`.",
+				"   - **`refactor`** — improve the implementation without changing behavior; the test must still pass.",
+				"",
+				"**Iron law**: every transition needs a cited artifact. You cannot write source code without a failing test on file. You cannot transition `red→green` without a `test_failed_run` artifact for the test you intend to make pass. You cannot transition `green→refactor` without a `test_passed_run`. The validator will deny transitions with missing or mis-bound evidence.",
+				"",
+				"When in doubt, run the failing test once and record the artifact via the post-tool hooks — don't try to record artifacts directly."
+			].join("\n")
+		}
+	}] };
+}
+
+//#endregion
+export { tddResumePrompt };

package/prompts/triage.js

@@ -0,0 +1,24 @@
+//#region src/prompts/triage.ts
+function triagePrompt(args) {
+	return { messages: [{
+		role: "user",
+		content: {
+			type: "text",
+			text: [
+				`You are starting a triage of the most recent test run${args.project ? ` (project filter: \`${args.project}\`)` : ""}.`,
+				"",
+				"Steps:",
+				"",
+				`1. Call \`triage_brief\`${args.project ? ` with \`project: "${args.project}"\`` : ""} to get the orientation summary.`,
+				"2. For any failures with a `signature_hash`, call `failure_signature_get` to read the recurrence history. A signature seen many times across recent runs points at a class of bug, not a fluke.",
+				"3. Form a hypothesis about the most likely root cause. Cite the specific evidence (test error, stack frame) you base the hypothesis on.",
+				"4. Record the hypothesis with `hypothesis_record`, citing the test_error_id and stack_frame_id. Once recorded, you (or the next agent) can validate it against a fix.",
+				"",
+				"Be specific. Avoid generic explanations like \"the test environment is misconfigured\" without evidence — those rarely turn out to be the cause."
+			].join("\n")
+		}
+	}] };
+}
+
+//#endregion
+export { triagePrompt };

package/prompts/why-flaky.js

@@ -0,0 +1,30 @@
+//#region src/prompts/why-flaky.ts
+function whyFlakyPrompt(args) {
+	const projectClause = args.project ? ` in project \`${args.project}\`` : "";
+	return { messages: [{
+		role: "user",
+		content: {
+			type: "text",
+			text: [
+				`Diagnose why the test \`${args.test}\` is flaky${projectClause}.`,
+				"",
+				"Steps:",
+				"",
+				`1. Call \`test_history\` for ${args.project ? `\`project: "${args.project}"\` and ` : ""}the named test to read the recent pass/fail pattern.`,
+				"2. For any recent failure with a `signature_hash`, call `failure_signature_get` to see whether the same signature has appeared in earlier runs. A repeating signature is structural; a one-off signature is environmental.",
+				"3. Look for these classic flake sources, in order:",
+				"   - **Timing-based assertions** — `vi.useFakeTimers` not paired with `vi.useRealTimers`, or assertions that race with `setTimeout`/`setInterval`.",
+				"   - **Shared state across tests** — module-level mutables, `globalThis`, file system fixtures not cleaned up.",
+				"   - **External I/O** — network calls without mocks, real database connections, real disk writes.",
+				"   - **Non-deterministic input** — `Date.now()`, `Math.random()`, environment-dependent paths.",
+				"",
+				"Decide: is this a **true flake** (intermittent based on timing/state) or an **environmental failure** (consistent given specific environment conditions)? They have different fixes.",
+				"",
+				"If you reach a conclusion, record it via `hypothesis_record` with the test_error_id and stack_frame_id of the most recent failure as evidence."
+			].join("\n")
+		}
+	}] };
+}
+
+//#endregion
+export { whyFlakyPrompt };

package/prompts/wrapup.js

@@ -0,0 +1,19 @@
+//#region src/prompts/wrapup.ts
+function wrapupPrompt(args) {
+	return { messages: [{
+		role: "user",
+		content: {
+			type: "text",
+			text: [
+				"Generate a wrapup for the current session.",
+				"",
+				`Call \`wrapup_prompt\` with \`kind: "${args.kind ?? "user_prompt_nudge"}"\`${args.since ? `, since: "${args.since}"` : ""} and read the returned markdown. The output is a short, human-readable summary of what happened in the session and what the user might want to do next.`,
+				"",
+				"This is identical content to what the post-Stop / post-SessionEnd hooks emit automatically — invoking it here is for moments when you want to surface the same summary on demand."
+			].join("\n")
+		}
+	}] };
+}
+
+//#endregion
+export { wrapupPrompt };

package/resources/index.js

@@ -0,0 +1,155 @@
+import { renderPatternsIndex, renderUpstreamIndex } from "./indexes.js";
+import { decodePatternsManifest, decodeUpstreamManifest } from "./manifest-schema.js";
+import { readPattern } from "./patterns.js";
+import { readUpstreamDoc } from "./upstream-docs.js";
+import { Effect } from "effect";
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+//#region src/resources/index.ts
+/**
+* Convert the readonly ResourceAnnotations decoded from a manifest into
+* the mutable shape the MCP SDK's Annotations type expects. The shape is
+* structurally identical; only the readonly-ness differs.
+*/
+function toSdkAnnotations(a) {
+	const out = {};
+	if (a.audience !== void 0) out.audience = [...a.audience];
+	if (a.priority !== void 0) out.priority = a.priority;
+	return out;
+}
+function resolveContentRoots() {
+	const here = dirname(fileURLToPath(import.meta.url));
+	const builtBase = here;
+	const sourceBase = join(here, "..");
+	const base = existsSync(join(builtBase, "vendor")) ? builtBase : sourceBase;
+	return {
+		vendorRoot: join(base, "vendor", "vitest-docs"),
+		patternsRoot: join(base, "patterns")
+	};
+}
+async function listManifestPages(vendorRoot) {
+	const manifestPath = join(vendorRoot, "manifest.json");
+	if (!existsSync(manifestPath)) return [];
+	let raw;
+	try {
+		raw = await readFile(manifestPath, "utf8");
+	} catch {
+		return [];
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return [];
+	}
+	const decoded = await Effect.runPromise(decodeUpstreamManifest(parsed).pipe(Effect.catchAll(() => Effect.succeed(null))));
+	if (!decoded?.pages) return [];
+	return decoded.pages.map((page) => ({
+		relativePath: page.path,
+		title: page.title,
+		description: page.description,
+		...page.annotations ? { annotations: page.annotations } : {}
+	}));
+}
+async function listPatternEntries(patternsRoot) {
+	const metaPath = join(patternsRoot, "_meta.json");
+	if (!existsSync(metaPath)) return [];
+	let raw;
+	try {
+		raw = await readFile(metaPath, "utf8");
+	} catch {
+		return [];
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return [];
+	}
+	const decoded = await Effect.runPromise(decodePatternsManifest(parsed).pipe(Effect.catchAll(() => Effect.succeed(null))));
+	if (!decoded) return [];
+	return decoded.patterns.map((p) => ({
+		slug: p.slug,
+		title: p.title,
+		summary: p.summary,
+		...p.annotations ? { annotations: p.annotations } : {}
+	}));
+}
+function registerAllResources(server) {
+	const { vendorRoot, patternsRoot } = resolveContentRoots();
+	server.registerResource("vitest_docs_index", "vitest://docs/", {
+		title: "Vitest documentation: index",
+		description: "Use first when you need any Vitest API, configuration, or behavioral information and aren't sure which page covers it — lists every page in the vendored snapshot grouped by section (api, config, guide) so you can pick the right `vitest://docs/<path>` URI before fetching.",
+		mimeType: "text/markdown"
+	}, async (uri) => {
+		const result = await renderUpstreamIndex(vendorRoot);
+		return { contents: [{
+			uri: uri.href,
+			mimeType: result.mimeType,
+			text: result.content
+		}] };
+	});
+	server.registerResource("vitest_docs_page", new ResourceTemplate("vitest://docs/{+path}", { list: async () => {
+		return { resources: (await listManifestPages(vendorRoot)).map((page) => ({
+			name: `vitest_docs_${page.relativePath.replace(/\//g, "_")}`,
+			uri: `vitest://docs/${page.relativePath}`,
+			title: page.title ?? page.relativePath,
+			description: page.description ?? `Vitest docs page: ${page.relativePath}`,
+			mimeType: "text/markdown",
+			...page.annotations ? { annotations: toSdkAnnotations(page.annotations) } : {}
+		})) };
+	} }), {
+		title: "Vitest Documentation Page",
+		description: "A single page from the vendored vitest.dev docs.",
+		mimeType: "text/markdown"
+	}, async (uri, variables) => {
+		const path = variables.path;
+		const result = await readUpstreamDoc(vendorRoot, Array.isArray(path) ? path.join("/") : String(path));
+		return { contents: [{
+			uri: uri.href,
+			mimeType: result.mimeType,
+			text: result.content
+		}] };
+	});
+	server.registerResource("vitest_agent_patterns_index", "vitest-agent://patterns/", {
+		title: "vitest-agent patterns: index",
+		description: "Use first when you need a curated vitest-agent pattern and want to discover what's available — lists every pattern slug with its title and one-line summary so you can pick the right `vitest-agent://patterns/<slug>` URI before fetching.",
+		mimeType: "text/markdown"
+	}, async (uri) => {
+		const result = await renderPatternsIndex(patternsRoot);
+		return { contents: [{
+			uri: uri.href,
+			mimeType: result.mimeType,
+			text: result.content
+		}] };
+	});
+	server.registerResource("vitest_agent_pattern", new ResourceTemplate("vitest-agent://patterns/{slug}", { list: async () => {
+		return { resources: (await listPatternEntries(patternsRoot)).map((p) => ({
+			name: `vitest_agent_pattern_${p.slug.replace(/[^A-Za-z0-9]/g, "_")}`,
+			uri: `vitest-agent://patterns/${p.slug}`,
+			title: p.title,
+			description: p.summary,
+			mimeType: "text/markdown",
+			...p.annotations ? { annotations: toSdkAnnotations(p.annotations) } : {}
+		})) };
+	} }), {
+		title: "vitest-agent Pattern",
+		description: "A single curated pattern from the vitest-agent project.",
+		mimeType: "text/markdown"
+	}, async (uri, variables) => {
+		const slug = variables.slug;
+		const result = await readPattern(patternsRoot, Array.isArray(slug) ? slug[0] : String(slug));
+		return { contents: [{
+			uri: uri.href,
+			mimeType: result.mimeType,
+			text: result.content
+		}] };
+	});
+}
+
+//#endregion
+export { registerAllResources };