@vitest-agent/mcp 1.0.0

package/tools/inventory.js

@@ -0,0 +1,377 @@
+import { publicProcedure } from "../context.js";
+import { DataReader } from "@vitest-agent/sdk";
+import { Effect, Match, Option, ParseResult, Schema } from "effect";
+
+//#region src/tools/inventory.ts
+/**
+* Consolidated `inventory` MCP tool — Schema-driven implementation.
+*
+* Each `kind` produces a structured result that the boundary in
+* server.ts can render as markdown via the exported
+* `formatInventoryMarkdown` helper. The structured payload uses an
+* `inventoryKind` discriminant (named separately from the input
+* `kind` because `session` collapses to two output shapes — one for
+* single-id lookup and one for list).
+*
+* @packageDocumentation
+*/
+const ProjectRunSummary = Schema.Struct({
+	project: Schema.String,
+	lastRun: Schema.NullOr(Schema.String),
+	lastResult: Schema.NullOr(Schema.Literal("passed", "failed", "interrupted")),
+	total: Schema.Number,
+	passed: Schema.Number,
+	failed: Schema.Number,
+	skipped: Schema.Number
+}).annotations({ identifier: "InventoryProjectRow" });
+const ModuleRow = Schema.Struct({
+	id: Schema.Number,
+	file: Schema.String,
+	state: Schema.String,
+	testCount: Schema.Number,
+	duration: Schema.NullOr(Schema.Number)
+}).annotations({ identifier: "InventoryModuleRow" });
+const SuiteRow = Schema.Struct({
+	id: Schema.Number,
+	name: Schema.String,
+	module: Schema.String,
+	state: Schema.String,
+	testCount: Schema.Number
+}).annotations({ identifier: "InventorySuiteRow" });
+const SessionRow = Schema.Struct({
+	id: Schema.Number,
+	chatId: Schema.String,
+	project: Schema.String,
+	cwd: Schema.String,
+	agentKind: Schema.Literal("main", "subagent"),
+	agentType: Schema.NullOr(Schema.String),
+	parentSessionId: Schema.NullOr(Schema.Number),
+	triageWasNonEmpty: Schema.Boolean,
+	startedAt: Schema.String,
+	endedAt: Schema.NullOr(Schema.String),
+	endReason: Schema.NullOr(Schema.String)
+}).annotations({ identifier: "InventorySessionRow" });
+const ProjectInventory = Schema.Struct({
+	inventoryKind: Schema.Literal("project"),
+	count: Schema.Number,
+	projects: Schema.Array(ProjectRunSummary)
+}).annotations({ identifier: "ProjectInventory" });
+const ModuleGroup = Schema.Struct({
+	project: Schema.String,
+	modules: Schema.Array(ModuleRow)
+});
+const ModuleInventory = Schema.Struct({
+	inventoryKind: Schema.Literal("module"),
+	count: Schema.Number,
+	groups: Schema.Array(ModuleGroup)
+}).annotations({ identifier: "ModuleInventory" });
+const SuiteGroup = Schema.Struct({
+	project: Schema.String,
+	suites: Schema.Array(SuiteRow)
+});
+const SuiteInventory = Schema.Struct({
+	inventoryKind: Schema.Literal("suite"),
+	count: Schema.Number,
+	groups: Schema.Array(SuiteGroup)
+}).annotations({ identifier: "SuiteInventory" });
+const SessionDetailFound = Schema.Struct({
+	inventoryKind: Schema.Literal("session_detail"),
+	found: Schema.Literal(true),
+	session: SessionRow
+}).annotations({ identifier: "SessionDetailFound" });
+const SessionDetailMissing = Schema.Struct({
+	inventoryKind: Schema.Literal("session_detail"),
+	found: Schema.Literal(false),
+	id: Schema.Number
+}).annotations({ identifier: "SessionDetailMissing" });
+const SessionListInventory = Schema.Struct({
+	inventoryKind: Schema.Literal("session_list"),
+	count: Schema.Number,
+	sessions: Schema.Array(SessionRow)
+}).annotations({ identifier: "SessionListInventory" });
+const TagProjectBreakdown = Schema.Struct({
+	project: Schema.String,
+	moduleCount: Schema.Number,
+	testCount: Schema.Number
+}).annotations({ identifier: "TagProjectBreakdown" });
+const TagRowScoped = Schema.Struct({
+	tag: Schema.String,
+	moduleCount: Schema.Number,
+	testCount: Schema.Number
+}).annotations({ identifier: "TagRowScoped" });
+const TagRowUnscoped = Schema.Struct({
+	tag: Schema.String,
+	moduleCount: Schema.Number,
+	testCount: Schema.Number,
+	byProject: Schema.Array(TagProjectBreakdown)
+}).annotations({ identifier: "TagRowUnscoped" });
+const TagInventoryScoped = Schema.Struct({
+	inventoryKind: Schema.Literal("tag_scoped"),
+	project: Schema.String,
+	count: Schema.Number,
+	tags: Schema.Array(TagRowScoped)
+}).annotations({ identifier: "TagInventoryScoped" });
+const TagInventoryUnscoped = Schema.Struct({
+	inventoryKind: Schema.Literal("tag_unscoped"),
+	count: Schema.Number,
+	tags: Schema.Array(TagRowUnscoped)
+}).annotations({ identifier: "TagInventoryUnscoped" });
+const InventoryResult = Schema.Union(ProjectInventory, ModuleInventory, SuiteInventory, SessionDetailFound, SessionDetailMissing, SessionListInventory, TagInventoryScoped, TagInventoryUnscoped).annotations({
+	identifier: "InventoryResult",
+	title: "inventory result",
+	description: "Discriminate on `inventoryKind`. project/module/suite carry counted lists; session_detail discriminates further on `found`; session_list returns the matching sessions; tag_scoped and tag_unscoped carry per-tag counts (the unscoped form also carries a `byProject` breakdown per tag)."
+});
+const formatInventoryMarkdown = (data) => {
+	if (data.inventoryKind === "project") {
+		if (data.count === 0) return "No projects found. Run tests first.";
+		const lines = [
+			"## Projects",
+			"",
+			"| Project | Last Run | Result | Total | Passed | Failed | Skipped |",
+			"| --- | --- | --- | --- | --- | --- | --- |"
+		];
+		for (const p of data.projects) {
+			const lastRun = p.lastRun ? p.lastRun.split("T")[0] : "—";
+			const result = p.lastResult ?? "—";
+			lines.push(`| ${p.project} | ${lastRun} | ${result} | ${p.total} | ${p.passed} | ${p.failed} | ${p.skipped} |`);
+		}
+		return lines.join("\n");
+	}
+	if (data.inventoryKind === "module") {
+		if (data.count === 0) return "No modules found. Run run_tests({}) to execute tests and populate the database.";
+		const lines = ["## Modules", ""];
+		for (const g of data.groups) {
+			lines.push(`### ${g.project}`, "", "| ID | File | State | Tests | Duration |", "| --- | --- | --- | --- | --- |");
+			for (const m of g.modules) {
+				const duration = m.duration !== null ? `${m.duration}ms` : "—";
+				lines.push(`| ${m.id} | ${m.file} | ${m.state} | ${m.testCount} | ${duration} |`);
+			}
+			lines.push("");
+		}
+		return lines.join("\n").trimEnd();
+	}
+	if (data.inventoryKind === "suite") {
+		if (data.count === 0) return "No suites found. Run run_tests({}) to execute tests and populate the database.";
+		const lines = ["## Suites", ""];
+		for (const g of data.groups) {
+			lines.push(`### ${g.project}`, "", "| ID | Name | Module | State | Tests |", "| --- | --- | --- | --- | --- |");
+			for (const s of g.suites) lines.push(`| ${s.id} | ${s.name} | ${s.module} | ${s.state} | ${s.testCount} |`);
+			lines.push("");
+		}
+		return lines.join("\n").trimEnd();
+	}
+	if (data.inventoryKind === "session_detail") {
+		if (!data.found) return `No session with id=${data.id}.`;
+		const s = data.session;
+		const lines = [
+			`# Session ${s.id}`,
+			"",
+			`- chatId: \`${s.chatId}\``,
+			`- project: ${s.project}`,
+			`- agentKind: ${s.agentKind}${s.agentType !== null ? ` (${s.agentType})` : ""}`,
+			`- started: ${s.startedAt}`,
+			`- ended: ${s.endedAt ?? "still open"}`,
+			`- triageWasNonEmpty: ${s.triageWasNonEmpty}`
+		];
+		if (s.parentSessionId !== null) lines.push(`- parentSessionId: ${s.parentSessionId}`);
+		return lines.join("\n");
+	}
+	if (data.inventoryKind === "tag_scoped") {
+		if (data.count === 0) return `No tags recorded for project \`${data.project}\`. Run run_tests({}) to populate.`;
+		const lines = [
+			`## Tags — ${data.project}`,
+			"",
+			"| Tag | Modules | Tests |",
+			"| --- | --- | --- |"
+		];
+		for (const t of data.tags) lines.push(`| ${t.tag} | ${t.moduleCount} | ${t.testCount} |`);
+		return lines.join("\n");
+	}
+	if (data.inventoryKind === "tag_unscoped") {
+		if (data.count === 0) return "No tags recorded. Run run_tests({}) to populate.";
+		const lines = [
+			"## Tags",
+			"",
+			"| Tag | Modules | Tests | Projects |",
+			"| --- | --- | --- | --- |"
+		];
+		for (const t of data.tags) {
+			const projectsBreakdown = t.byProject.map((p) => `${p.project} (${p.testCount})`).join(", ");
+			lines.push(`| ${t.tag} | ${t.moduleCount} | ${t.testCount} | ${projectsBreakdown} |`);
+		}
+		return lines.join("\n");
+	}
+	if (data.count === 0) return "No sessions recorded yet.";
+	const lines = ["# Sessions", ""];
+	for (const s of data.sessions) {
+		const ended = s.endedAt ? `ended ${s.endedAt}` : "open";
+		lines.push(`- **${s.chatId}** [${s.agentKind}] project=${s.project} started=${s.startedAt} ${ended}`);
+	}
+	return lines.join("\n");
+};
+const InventoryAsMarkdown = Schema.transformOrFail(InventoryResult, Schema.String, {
+	strict: true,
+	decode: (data) => ParseResult.succeed(formatInventoryMarkdown(data)),
+	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "InventoryAsMarkdown is one-way."))
+});
+const ProjectVariant = Schema.Struct({ kind: Schema.Literal("project") });
+const ModuleVariant = Schema.Struct({
+	kind: Schema.Literal("module"),
+	project: Schema.optional(Schema.String)
+});
+const SuiteVariant = Schema.Struct({
+	kind: Schema.Literal("suite"),
+	project: Schema.optional(Schema.String),
+	module: Schema.optional(Schema.String)
+});
+const SessionVariant = Schema.Struct({
+	kind: Schema.Literal("session"),
+	id: Schema.optional(Schema.Number),
+	project: Schema.optional(Schema.String),
+	agentKind: Schema.optional(Schema.Literal("main", "subagent")),
+	limit: Schema.optional(Schema.Number)
+});
+const TagVariant = Schema.Struct({
+	kind: Schema.Literal("tag"),
+	project: Schema.optional(Schema.String)
+});
+const InventoryInput = Schema.Union(ProjectVariant, ModuleVariant, SuiteVariant, SessionVariant, TagVariant);
+const inventory = publicProcedure.input(Schema.standardSchemaV1(InventoryInput)).query(async ({ ctx, input }) => {
+	return ctx.runtime.runPromise(Match.value(input).pipe(Match.discriminatorsExhaustive("kind")({
+		project: () => Effect.gen(function* () {
+			const projects = yield* (yield* DataReader).getRunsByProject();
+			return {
+				inventoryKind: "project",
+				count: projects.length,
+				projects: projects.map((p) => ({
+					project: p.project,
+					lastRun: p.lastRun,
+					lastResult: p.lastResult,
+					total: p.total,
+					passed: p.passed,
+					failed: p.failed,
+					skipped: p.skipped
+				}))
+			};
+		}),
+		module: (variant) => Effect.gen(function* () {
+			const reader = yield* DataReader;
+			const targets = variant.project ? [{ project: variant.project }] : yield* reader.getRunsByProject().pipe(Effect.map((rs) => rs.map((r) => ({ project: r.project }))));
+			const groups = [];
+			let total = 0;
+			for (const t of targets) {
+				const modules = yield* reader.listModules(t.project);
+				if (modules.length > 0) {
+					groups.push({
+						project: t.project,
+						modules
+					});
+					total += modules.length;
+				}
+			}
+			return {
+				inventoryKind: "module",
+				count: total,
+				groups
+			};
+		}),
+		suite: (variant) => Effect.gen(function* () {
+			const reader = yield* DataReader;
+			const opts = {};
+			if (variant.module !== void 0) opts.module = variant.module;
+			const targets = variant.project ? [{ project: variant.project }] : yield* reader.getRunsByProject().pipe(Effect.map((rs) => rs.map((r) => ({ project: r.project }))));
+			const groups = [];
+			let total = 0;
+			for (const t of targets) {
+				const suites = yield* reader.listSuites(t.project, opts);
+				if (suites.length > 0) {
+					groups.push({
+						project: t.project,
+						suites
+					});
+					total += suites.length;
+				}
+			}
+			return {
+				inventoryKind: "suite",
+				count: total,
+				groups
+			};
+		}),
+		session: (variant) => Effect.gen(function* () {
+			const reader = yield* DataReader;
+			if (variant.id !== void 0) {
+				const opt = yield* reader.getSessionById(variant.id);
+				return Option.isNone(opt) ? {
+					inventoryKind: "session_detail",
+					found: false,
+					id: variant.id
+				} : {
+					inventoryKind: "session_detail",
+					found: true,
+					session: opt.value
+				};
+			}
+			const rows = yield* reader.listSessions({
+				...variant.project !== void 0 && { project: variant.project },
+				...variant.agentKind !== void 0 && { agentKind: variant.agentKind },
+				...variant.limit !== void 0 && { limit: variant.limit }
+			});
+			return {
+				inventoryKind: "session_list",
+				count: rows.length,
+				sessions: rows
+			};
+		}),
+		tag: (variant) => Effect.gen(function* () {
+			const reader = yield* DataReader;
+			if (variant.project !== void 0) {
+				const rows = yield* reader.listTagInventory({ project: variant.project });
+				return {
+					inventoryKind: "tag_scoped",
+					project: variant.project,
+					count: rows.length,
+					tags: rows.map((r) => ({
+						tag: r.tag,
+						moduleCount: r.moduleCount,
+						testCount: r.testCount
+					}))
+				};
+			}
+			const rows = yield* reader.listTagInventory();
+			const byTag = /* @__PURE__ */ new Map();
+			for (const r of rows) {
+				let entry = byTag.get(r.tag);
+				if (entry === void 0) {
+					entry = {
+						moduleCount: 0,
+						testCount: 0,
+						byProject: []
+					};
+					byTag.set(r.tag, entry);
+				}
+				entry.moduleCount += r.moduleCount;
+				entry.testCount += r.testCount;
+				entry.byProject.push({
+					project: r.project,
+					moduleCount: r.moduleCount,
+					testCount: r.testCount
+				});
+			}
+			const tags = Array.from(byTag.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([tag, e]) => ({
+				tag,
+				moduleCount: e.moduleCount,
+				testCount: e.testCount,
+				byProject: e.byProject
+			}));
+			return {
+				inventoryKind: "tag_unscoped",
+				count: tags.length,
+				tags
+			};
+		})
+	})));
+});
+
+//#endregion
+export { InventoryAsMarkdown, InventoryResult, inventory };

package/tools/note.js

@@ -0,0 +1,208 @@
+import { publicProcedure } from "../context.js";
+import { DataReader, DataStore } from "@vitest-agent/sdk";
+import { Effect, Match, Option, Schema } from "effect";
+
+//#region src/tools/note.ts
+const NoteScope = Schema.Literal("global", "project", "module", "suite", "test", "note");
+const NoteRowSchema = Schema.Struct({
+	id: Schema.Number.annotations({ description: "Note primary key." }),
+	title: Schema.String,
+	content: Schema.String,
+	scope: NoteScope.annotations({ description: "`global` (project-agnostic), `project`, `module`, `suite`, `test` (scoped), or `note` (child note attached via `parentNoteId`)." }),
+	project: Schema.NullOr(Schema.String),
+	testFullName: Schema.NullOr(Schema.String),
+	modulePath: Schema.NullOr(Schema.String),
+	parentNoteId: Schema.NullOr(Schema.Number),
+	createdBy: Schema.NullOr(Schema.String),
+	expiresAt: Schema.NullOr(Schema.String),
+	pinned: Schema.Boolean,
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+}).annotations({ identifier: "NoteRow" });
+const NoteCreateOk = Schema.Struct({
+	action: Schema.Literal("create"),
+	id: Schema.Number.annotations({ description: "Primary key of the newly inserted note." })
+});
+const NoteListOk = Schema.Struct({
+	action: Schema.Literal("list"),
+	count: Schema.Number,
+	notes: Schema.Array(NoteRowSchema).annotations({ description: "Notes matching the optional scope/project/test filters." })
+});
+const NoteGetFound = Schema.Struct({
+	action: Schema.Literal("get"),
+	found: Schema.Literal(true),
+	note: NoteRowSchema
+});
+const NoteGetMissing = Schema.Struct({
+	action: Schema.Literal("get"),
+	found: Schema.Literal(false),
+	id: Schema.Number
+});
+const NoteUpdateOk = Schema.Struct({
+	action: Schema.Literal("update"),
+	success: Schema.Literal(true)
+});
+const NoteDeleteOk = Schema.Struct({
+	action: Schema.Literal("delete"),
+	success: Schema.Literal(true)
+});
+const NoteSearchOk = Schema.Struct({
+	action: Schema.Literal("search"),
+	query: Schema.String,
+	count: Schema.Number,
+	notes: Schema.Array(NoteRowSchema).annotations({ description: "Notes whose title or content match the FTS5 query." })
+});
+const NoteResult = Schema.Union(NoteCreateOk, NoteListOk, NoteGetFound, NoteGetMissing, NoteUpdateOk, NoteDeleteOk, NoteSearchOk).annotations({
+	identifier: "NoteResult",
+	title: "note result",
+	description: "Discriminate on `action`. `get` further discriminates on `found`."
+});
+const renderNoteTable = (notes) => {
+	const lines = ["| ID | Title | Scope | Project | Created |", "| --- | --- | --- | --- | --- |"];
+	for (const n of notes) {
+		const proj = n.project ?? "—";
+		const created = n.createdAt.split("T")[0];
+		lines.push(`| ${n.id} | ${n.title} | ${n.scope} | ${proj} | ${created} |`);
+	}
+	return lines.join("\n");
+};
+/**
+* Markdown rendering used at the boundary for note list/search
+* results. Mutations (create/get/update/delete) get JSON-stringify
+* via `structuredJsonResult` instead of a markdown view.
+*/
+const formatNoteListMarkdown = (data) => {
+	if (data.action === "list") {
+		if (data.notes.length === 0) return "No notes found. Use note({ action: \"create\", ... }) to add notes.";
+		return [
+			"## Notes",
+			"",
+			renderNoteTable(data.notes)
+		].join("\n");
+	}
+	if (data.action === "search") {
+		if (data.notes.length === 0) return "No notes matched.";
+		return [
+			`## Notes matching "${data.query}"`,
+			"",
+			renderNoteTable(data.notes)
+		].join("\n");
+	}
+	return JSON.stringify(data, null, 2);
+};
+const CreateVariant = Schema.Struct({
+	action: Schema.Literal("create"),
+	title: Schema.String,
+	content: Schema.String,
+	scope: NoteScope,
+	project: Schema.optional(Schema.String),
+	testFullName: Schema.optional(Schema.String),
+	modulePath: Schema.optional(Schema.String),
+	parentNoteId: Schema.optional(Schema.Number),
+	createdBy: Schema.optional(Schema.String),
+	expiresAt: Schema.optional(Schema.String),
+	pinned: Schema.optional(Schema.Boolean)
+});
+const ListVariant = Schema.Struct({
+	action: Schema.Literal("list"),
+	scope: Schema.optional(Schema.String),
+	project: Schema.optional(Schema.String),
+	testFullName: Schema.optional(Schema.String)
+});
+const GetVariant = Schema.Struct({
+	action: Schema.Literal("get"),
+	id: Schema.Number
+});
+const UpdateVariant = Schema.Struct({
+	action: Schema.Literal("update"),
+	id: Schema.Number,
+	title: Schema.optional(Schema.String),
+	content: Schema.optional(Schema.String),
+	pinned: Schema.optional(Schema.Boolean),
+	expiresAt: Schema.optional(Schema.String)
+});
+const DeleteVariant = Schema.Struct({
+	action: Schema.Literal("delete"),
+	id: Schema.Number
+});
+const SearchVariant = Schema.Struct({
+	action: Schema.Literal("search"),
+	query: Schema.String
+});
+const NoteInputUnion = Schema.Union(CreateVariant, ListVariant, GetVariant, UpdateVariant, DeleteVariant, SearchVariant);
+const note = publicProcedure.input(Schema.standardSchemaV1(NoteInputUnion)).mutation(async ({ ctx, input }) => {
+	return ctx.runtime.runPromise(Match.value(input).pipe(Match.discriminatorsExhaustive("action")({
+		create: (variant) => Effect.gen(function* () {
+			const store = yield* DataStore;
+			const noteInput = {
+				title: variant.title,
+				content: variant.content,
+				scope: variant.scope,
+				...variant.project !== void 0 && { project: variant.project },
+				...variant.testFullName !== void 0 && { testFullName: variant.testFullName },
+				...variant.modulePath !== void 0 && { modulePath: variant.modulePath },
+				...variant.parentNoteId !== void 0 && { parentNoteId: variant.parentNoteId },
+				...variant.createdBy !== void 0 && { createdBy: variant.createdBy },
+				...variant.expiresAt !== void 0 && { expiresAt: variant.expiresAt },
+				...variant.pinned !== void 0 && { pinned: variant.pinned }
+			};
+			return {
+				action: "create",
+				id: yield* store.writeNote(noteInput)
+			};
+		}),
+		list: (variant) => Effect.gen(function* () {
+			const notes = yield* (yield* DataReader).getNotes(variant.scope, variant.project, variant.testFullName);
+			return {
+				action: "list",
+				count: notes.length,
+				notes
+			};
+		}),
+		get: (variant) => Effect.gen(function* () {
+			const noteOpt = yield* (yield* DataReader).getNoteById(variant.id);
+			return Option.isNone(noteOpt) ? {
+				action: "get",
+				found: false,
+				id: variant.id
+			} : {
+				action: "get",
+				found: true,
+				note: noteOpt.value
+			};
+		}),
+		update: (variant) => Effect.gen(function* () {
+			const store = yield* DataStore;
+			const fields = {
+				...variant.title !== void 0 && { title: variant.title },
+				...variant.content !== void 0 && { content: variant.content },
+				...variant.pinned !== void 0 && { pinned: variant.pinned },
+				...variant.expiresAt !== void 0 && { expiresAt: variant.expiresAt }
+			};
+			yield* store.updateNote(variant.id, fields);
+			return {
+				action: "update",
+				success: true
+			};
+		}),
+		delete: (variant) => Effect.gen(function* () {
+			yield* (yield* DataStore).deleteNote(variant.id);
+			return {
+				action: "delete",
+				success: true
+			};
+		}),
+		search: (variant) => Effect.gen(function* () {
+			const notes = yield* (yield* DataReader).searchNotes(variant.query);
+			return {
+				action: "search",
+				query: variant.query,
+				count: notes.length,
+				notes
+			};
+		})
+	})));
+});
+
+//#endregion
+export { NoteResult, formatNoteListMarkdown, note };

package/tools/overview.js

@@ -0,0 +1,92 @@
+import { publicProcedure } from "../context.js";
+import { DataReader } from "@vitest-agent/sdk";
+import { Effect, Option, ParseResult, Schema } from "effect";
+
+//#region src/tools/overview.ts
+/**
+* `test_overview` MCP tool — Schema-driven implementation.
+*
+* @packageDocumentation
+*/
+const ProjectRunSummary = Schema.Struct({
+	project: Schema.String,
+	lastRun: Schema.NullOr(Schema.String),
+	lastResult: Schema.NullOr(Schema.Literal("passed", "failed", "interrupted")),
+	total: Schema.Number,
+	passed: Schema.Number,
+	failed: Schema.Number,
+	skipped: Schema.Number
+}).annotations({
+	identifier: "ProjectRunSummary",
+	description: "One row per project's most recent run summary."
+});
+const OverviewAvailable = Schema.Struct({
+	dataAvailable: Schema.Literal(true),
+	projectFilter: Schema.optional(Schema.String),
+	runs: Schema.Array(ProjectRunSummary)
+}).annotations({ identifier: "TestOverviewAvailable" });
+const OverviewAbsent = Schema.Struct({
+	dataAvailable: Schema.Literal(false),
+	projectFilter: Schema.optional(Schema.String),
+	reason: Schema.Literal("no_runs", "project_filter_empty")
+}).annotations({ identifier: "TestOverviewAbsent" });
+const TestOverviewResult = Schema.Union(OverviewAvailable, OverviewAbsent).annotations({
+	identifier: "TestOverviewResult",
+	title: "test_overview result",
+	description: "Per-project run metrics. Discriminate on `dataAvailable` for cold-start handling."
+});
+const iconForResult = (r) => {
+	if (r === "passed") return "✅";
+	if (r === "failed") return "❌";
+	if (r === "interrupted") return "⚠️";
+	return "⬜";
+};
+const formatTestOverviewMarkdown = (data) => {
+	if (!data.dataAvailable) {
+		if (data.reason === "project_filter_empty") return `No test data found for project \`${data.projectFilter ?? "(unknown)"}\`. Run tests first.`;
+		return "No test data available. Run tests first.";
+	}
+	const lines = ["# Test Overview", ""];
+	const projectGroups = /* @__PURE__ */ new Map();
+	for (const run of data.runs) {
+		const group = projectGroups.get(run.project) ?? [];
+		group.push(run);
+		projectGroups.set(run.project, group);
+	}
+	for (const [projectName, projectRuns] of projectGroups) {
+		lines.push(`## ${projectName}`, "");
+		for (const run of projectRuns) {
+			const lastRun = run.lastRun ? new Date(run.lastRun).toLocaleString() : "never";
+			lines.push(`### ${iconForResult(run.lastResult)} ${run.project}`, "", "| Metric | Count |", "| --- | --- |", `| Total | ${run.total} |`, `| Passed | ${run.passed} |`, `| Failed | ${run.failed} |`, `| Skipped | ${run.skipped} |`, `| Last run | ${lastRun} |`, "");
+		}
+	}
+	return lines.join("\n");
+};
+const TestOverviewAsMarkdown = Schema.transformOrFail(TestOverviewResult, Schema.String, {
+	strict: true,
+	decode: (data) => ParseResult.succeed(formatTestOverviewMarkdown(data)),
+	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "TestOverviewAsMarkdown is one-way."))
+});
+const testOverview = publicProcedure.input(Schema.standardSchemaV1(Schema.Struct({ project: Schema.optional(Schema.String) }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
+	const reader = yield* DataReader;
+	const [manifestOpt, runs] = yield* Effect.all([reader.getManifest(), reader.getRunsByProject()]);
+	if (Option.isNone(manifestOpt) || runs.length === 0) return {
+		dataAvailable: false,
+		reason: "no_runs",
+		...input.project !== void 0 && { projectFilter: input.project }
+	};
+	const filteredRuns = input.project === void 0 ? runs : runs.filter((r) => r.project === input.project);
+	if (filteredRuns.length === 0) return {
+		dataAvailable: false,
+		reason: "project_filter_empty",
+		...input.project !== void 0 && { projectFilter: input.project }
+	};
+	return {
+		dataAvailable: true,
+		...input.project !== void 0 && { projectFilter: input.project },
+		runs: filteredRuns
+	};
+})));
+
+//#endregion
+export { TestOverviewAsMarkdown, TestOverviewResult, testOverview };

package/tools/ping.js

@@ -0,0 +1,22 @@
+import { publicProcedure } from "../context.js";
+import { Schema } from "effect";
+
+//#region src/tools/ping.ts
+/**
+* `ping` MCP tool — Schema-driven implementation.
+*
+* Trivial liveness probe used to verify hot-patch reload of the MCP
+* server. Returns the canonical `pong` payload so callers can assert
+* a healthy round-trip.
+*
+* @packageDocumentation
+*/
+const PingResult = Schema.Struct({ message: Schema.Literal("pong").annotations({ description: "Constant `pong`. Presence confirms the MCP server responded." }) }).annotations({
+	identifier: "PingResult",
+	title: "ping result",
+	description: "Liveness probe. Carries no data beyond the constant `pong` discriminant."
+});
+const ping = publicProcedure.query(async () => ({ message: "pong" }));
+
+//#endregion
+export { PingResult, ping };