@vitest-agent/mcp 4.2.2 → 4.3.0

package/annotations.js

@@ -2,14 +2,14 @@ import { Context } from "effect";
 
 //#region src/annotations.ts
 /**
-* Renders a tool's encoded result as the human-readable `content[0].text`
-* channel (markdown, typically). Returning `undefined` — or leaving the
-* annotation unset — falls back to `JSON.stringify(encoded)`.
-*
-* Attach with `tool.annotate(RenderText, (encoded) => ...)`; the renderer
-* receives the wire-encoded result (the same value that becomes
-* `structuredContent`), never the decoded domain value.
+* Formerly rendered a tool's encoded result as a markdown `content[0].text`
+* channel. The server no longer reads it: every successful result carries
+* the typed object in `structuredContent` and its JSON in `content[0].text`,
+* because Claude Code forwards only `structuredContent` to the model.
+* Attaching it is a no-op.
 *
+* @deprecated Nothing reads this annotation any more; remove the
+* `.annotate(RenderText, ...)` call. It will be removed in the next major.
 * @public
 */
 const RenderText = Context.Reference("@vitest-agent/mcp/RenderText", { defaultValue: () => void 0 });

package/index.d.ts

@@ -4,14 +4,14 @@ import { McpSchema, Tool, Toolkit } from "effect/unstable/ai";
 import "@vitest-agent/sdk";
 //#region src/annotations.d.ts
 /**
- * Renders a tool's encoded result as the human-readable `content[0].text`
- * channel (markdown, typically). Returning `undefined` — or leaving the
- * annotation unset — falls back to `JSON.stringify(encoded)`.
- *
- * Attach with `tool.annotate(RenderText, (encoded) => ...)`; the renderer
- * receives the wire-encoded result (the same value that becomes
- * `structuredContent`), never the decoded domain value.
+ * Formerly rendered a tool's encoded result as a markdown `content[0].text`
+ * channel. The server no longer reads it: every successful result carries
+ * the typed object in `structuredContent` and its JSON in `content[0].text`,
+ * because Claude Code forwards only `structuredContent` to the model.
+ * Attaching it is a no-op.
  *
+ * @deprecated Nothing reads this annotation any more; remove the
+ * `.annotate(RenderText, ...)` call. It will be removed in the next major.
  * @public
  */
 export declare const RenderText: Context.Reference<((result: unknown) => string | undefined) | undefined>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/mcp",
-	"version": "4.2.2",
+	"version": "4.3.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": [

package/prompts/layer.js

@@ -38,12 +38,14 @@ const toMessages = (result) => result.messages.map((m) => ({
 const projectArg = Schema.optionalKey(Schema.String.annotate({ description: "Filter to a specific project" }));
 const Triage = McpServer.prompt({
 	name: PROMPT_NAMES[0],
+	title: "Triage Recent Failures",
 	description: "Orient toward a triage workflow over the most recent test run; compose triage_brief, failure_signature_get, hypothesis_record.",
 	parameters: { project: projectArg },
 	content: (args) => Effect.succeed(toMessages(triagePrompt(args.project !== void 0 ? { project: args.project } : {})))
 });
 const WhyFlaky = McpServer.prompt({
 	name: PROMPT_NAMES[1],
+	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.",
 	parameters: {
 		test: Schema.String.annotate({ description: "Full hierarchical test name (e.g. 'Suite > nested > test')" }),
@@ -56,6 +58,7 @@ const WhyFlaky = McpServer.prompt({
 });
 const RegressionSincePass = McpServer.prompt({
 	name: PROMPT_NAMES[2],
+	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.",
 	parameters: {
 		test: Schema.String.annotate({ description: "Full hierarchical test name" }),
@@ -68,12 +71,14 @@ const RegressionSincePass = McpServer.prompt({
 });
 const ExplainFailure = McpServer.prompt({
 	name: PROMPT_NAMES[3],
+	title: "Explain a Failure Class",
 	description: "Synthesize a root-cause explanation from the recurrence history of a failure signature.",
 	parameters: { signature: Schema.String.annotate({ description: "16-char failure signature hex" }) },
 	content: (args) => Effect.succeed(toMessages(explainFailurePrompt({ signature: args.signature })))
 });
 const TddResume = McpServer.prompt({
 	name: PROMPT_NAMES[4],
+	title: "Resume TDD Work",
 	description: "Resume the active TDD task from its current phase; iron-law reminder for evidence-bound transitions.",
 	parameters: { sessionId: Schema.optionalKey(Schema.String.annotate({ description: "Host session id (defaults to MCP server's recovered SessionContext)" })) },
 	content: (args) => Effect.gen(function* () {
@@ -84,6 +89,7 @@ const TddResume = McpServer.prompt({
 });
 const Wrapup = McpServer.prompt({
 	name: PROMPT_NAMES[5],
+	title: "Generate a Session Wrapup",
 	description: "Surface the same wrapup content the post-hooks emit automatically.",
 	parameters: {
 		kind: Schema.optionalKey(Schema.Literals(WRAPUP_KINDS).annotate({ description: "Wrapup variant (default: user_prompt_nudge)" })),

package/register-toolkit.js

@@ -1,4 +1,3 @@
-import { RenderText } from "./annotations.js";
 import { buildUnexpectedToolErrorEnvelope } from "./utils/tool-error-envelope.js";
 import { Cause, Context, Effect, ErrorReporter, Layer, Option, References, Result, Schema, Stream } from "effect";
 import { AiError, McpSchema, McpServer, Tool, Toolkit } from "effect/unstable/ai";
@@ -68,48 +67,22 @@ const inlineRootRefs = (schema) => {
 	};
 };
 /**
-* Deep-copy `schema`, setting `additionalProperties: false` on every
-* object node that declares `properties` (or is a bare object with no
-* combinator), and rewriting a top-level union of discriminated object
-* shapes to `{ type: "object", oneOf, "x-discriminator" }` so the served
-* schema still satisfies MCP's object-root requirement.
+* Make an input JSON Schema servable as an MCP tool input: inline a `$ref`
+* root (and `$ref` members of a top-level union), and rewrite a top-level
+* union of discriminated object shapes to `{ type: "object", oneOf,
+* "x-discriminator" }` so it satisfies MCP's object-root requirement. The
+* object nodes themselves are left as Effect emitted them — closed, when the
+* document was built with `onExcessProperty: "error"`.
 *
 * @internal
 */
-const strictifyJsonSchema = (schema) => {
-	const visit = (node) => {
-		if (Array.isArray(node)) return node.map(visit);
-		if (!isPlainObject(node)) return node;
-		const out = {};
-		for (const [key, value] of Object.entries(node)) switch (key) {
-			case "properties":
-			case "$defs":
-			case "definitions":
-				out[key] = isPlainObject(value) ? Object.fromEntries(Object.entries(value).map(([k, v]) => [k, visit(v)])) : value;
-				break;
-			case "items":
-			case "prefixItems":
-			case "anyOf":
-			case "oneOf":
-			case "allOf":
-			case "not":
-				out[key] = visit(value);
-				break;
-			case "additionalProperties":
-				out[key] = isPlainObject(value) ? visit(value) : value;
-				break;
-			default: out[key] = value;
-		}
-		const hasCombinator = Array.isArray(out.anyOf) || Array.isArray(out.oneOf) || Array.isArray(out.allOf);
-		if ((out.type === "object" || isPlainObject(out.properties)) && !hasCombinator && !isPlainObject(out.additionalProperties)) out.additionalProperties = false;
-		return out;
-	};
-	const strict = visit(inlineRootRefs(schema));
-	const members = strict.anyOf ?? strict.oneOf;
-	if (Array.isArray(members) && strict.type === void 0) {
+const objectRootedInputSchema = (schema) => {
+	const root = inlineRootRefs(schema);
+	const members = root.anyOf ?? root.oneOf;
+	if (Array.isArray(members) && root.type === void 0) {
 		const discriminant = findDiscriminant(members);
 		if (discriminant !== void 0) {
-			const { anyOf: _anyOf, oneOf: _oneOf, ...rest } = strict;
+			const { anyOf: _anyOf, oneOf: _oneOf, ...rest } = root;
 			return {
 				type: "object",
 				...rest,
@@ -118,7 +91,7 @@ const strictifyJsonSchema = (schema) => {
 			};
 		}
 	}
-	return strict;
+	return root;
 };
 const resolveRef = (node, root) => lookupRef(node.$ref, root) ?? node;
 /** Pick the union member a payload object matches, or `undefined` when none does unambiguously. */
@@ -229,17 +202,20 @@ const toolResultContent = (encoded) => encoded === void 0 ? [] : [{
 const omitRequestServices = Context.omit(McpSchema.McpRequestContext, McpSchema.McpServerClient, HttpServerRequest.HttpServerRequest, References.CurrentLogLevel);
 const isParameterValidationError = (error) => AiError.isAiError(error) && error.reason._tag === "ToolParameterValidationError";
 /**
-* The input JSON Schema document as rc.116's `toolInputJsonSchema` builds it
-* (`Schema.toJsonSchemaDocument` with `onExcessProperty` following the
-* tool's strict mode, definitions attached as `$defs`); the top-level `$ref`
-* hoist happens in `inlineRootRefs` via `strictifyJsonSchema`.
+* The input JSON Schema a tool is served with: the document rc.116's
+* `toolInputJsonSchema` builds for a strict tool (`Schema.toJsonSchemaDocument`
+* with `onExcessProperty: "error"`, so every object node carries
+* `additionalProperties: false`; definitions attached as `$defs`), made
+* object-rooted by {@link objectRootedInputSchema}.
+*
+* @internal
 */
-const toolInputJsonSchema = (schema, strict) => {
-	const document = Schema.toJsonSchemaDocument(schema, { onExcessProperty: strict ? "error" : "ignore" });
-	return Object.keys(document.definitions).length === 0 ? document.schema : {
+const servedInputJsonSchema = (schema) => {
+	const document = Schema.toJsonSchemaDocument(schema, { onExcessProperty: "error" });
+	return objectRootedInputSchema(Object.keys(document.definitions).length === 0 ? document.schema : {
 		...document.schema,
 		$defs: document.definitions
-	};
+	});
 };
 const envelopeResult = (toolName, err) => {
 	const envelope = buildUnexpectedToolErrorEnvelope(toolName, err);
@@ -281,12 +257,9 @@ const registerStrictToolkitEffect = Effect.fnUntraced(function* (toolkit) {
 			const failure = Cause.findFail(cause);
 			return Result.isFailure(failure) && !Cause.hasDies(cause) ? Effect.failCause(failure.failure) : Effect.logError(`tool ${tool.name} failed`, cause).pipe(Effect.andThen(reportCause(cause)), Effect.as(envelopeResult(tool.name, Result.isSuccess(failure) ? failure.success.error : Cause.squash(cause))));
 		};
-		const strict = Tool.getStrictMode(tool) === true;
-		const rawJsonSchema = Tool.isDynamic(tool) ? tool.jsonSchema : void 0;
-		if (strict && rawJsonSchema !== void 0) return yield* Effect.die(`McpServer cannot strictly validate the raw JSON Schema for tool '${tool.name}'; use an Effect Schema instead`);
-		const decodeOptions = strict ? { onExcessProperty: "error" } : void 0;
+		if (Tool.isDynamic(tool)) return yield* Effect.die(`McpServer cannot strictly validate the raw JSON Schema for tool '${tool.name}'; use an Effect Schema instead`);
+		const decodeOptions = { onExcessProperty: "error" };
 		const annotations = tool.annotations;
-		const render = Context.get(annotations, RenderText);
 		const toolMeta = Context.getOrUndefined(annotations, Tool.Meta);
 		const isDeclaredFailure = Schema.is(tool.failureSchema);
 		const encodeFailure = Schema.encodeUnknownEffect(tool.failureSchema);
@@ -306,7 +279,7 @@ const registerStrictToolkitEffect = Effect.fnUntraced(function* (toolkit) {
 		};
 		const outputJsonSchema = inlineRootRefs(Tool.getJsonSchemaFromSchema(tool.successSchema));
 		const outputSchema = outputJsonSchema.type === "object" ? yield* Schema.decodeUnknownEffect(McpSchema.ToolOutputJson)(outputJsonSchema).pipe(Effect.orDie) : void 0;
-		const servedInput = strictifyJsonSchema(rawJsonSchema ?? toolInputJsonSchema(tool.parametersSchema, strict));
+		const servedInput = servedInputJsonSchema(tool.parametersSchema);
 		const inputSchema = yield* Schema.decodeUnknownEffect(McpSchema.ToolJson)(servedInput).pipe(Effect.orDie);
 		const description = Tool.getDescription(tool);
 		const mcpTool = new McpSchema.Tool({
@@ -333,10 +306,7 @@ const registerStrictToolkitEffect = Effect.fnUntraced(function* (toolkit) {
 				return built.handle(tool.name, raw, void 0, decodeOptions).pipe(Stream.unwrap, Stream.runLast, Effect.flatMap(Effect.fromOption), Effect.flatMap((result) => result.isFailure && result.failureOrigin !== "handler" ? Effect.failCause(Cause.annotate(Cause.fail(result.result), Context.make(Toolkit.FailureOrigin, result.failureOrigin ?? "result"))) : Effect.succeed(new McpSchema.CallToolResult({
 					isError: result.isFailure,
 					structuredContent: result.isFailure ? void 0 : toStructuredContent(result.encodedResult),
-					content: result.isFailure || result.encodedResult === void 0 ? toolResultContent(result.encodedResult) : [{
-						type: "text",
-						text: render?.(result.encodedResult) ?? JSON.stringify(result.encodedResult)
-					}]
+					content: toolResultContent(result.encodedResult)
 				}))), Effect.catchCause(handleCause), Effect.provideContext(services));
 			}
 		});
@@ -355,4 +325,4 @@ const registerStrictToolkitEffect = Effect.fnUntraced(function* (toolkit) {
 const registerStrictToolkit = (toolkit) => Layer.effectDiscard(registerStrictToolkitEffect(toolkit)).pipe(Layer.provide(McpServer.McpServer.layer));
 
 //#endregion
-export { collectUnknownKeys, inlineRootRefs, registerStrictToolkit, registerStrictToolkitEffect, strictifyJsonSchema };
+export { collectUnknownKeys, inlineRootRefs, objectRootedInputSchema, registerStrictToolkit, registerStrictToolkitEffect, servedInputJsonSchema };

package/server.js

@@ -20,7 +20,7 @@ const SERVER_INSTRUCTIONS = [
 	"vitest-agent serves the test landscape of one Vitest project to LLM coding agents: run results, failure detail and history, coverage, flakiness, and the TDD lifecycle (tasks, goals, behaviors, phase transitions, hypotheses, notes).",
 	"Call the help tool first for the full tool reference; triage_brief orients on the current landscape; run_tests executes Vitest and persists the run so every query tool reads it back.",
 	"Every input is strict at every object level: an unknown key is rejected with a message naming the unrecognized key(s) and the accepted params, so fix the call rather than retrying it.",
-	"Every successful result carries the typed object in structuredContent and a text rendering (markdown where the tool renders one, otherwise the same JSON) in content[0].text; read structuredContent when you need fields.",
+	"Every successful result carries the typed object in structuredContent, and content[0].text holds the same object as JSON; read structuredContent when you need fields.",
 	"An expected domain error is NOT an isError result: it is a normal result whose structuredContent has ok: false and an error object. tdd_goal and tdd_behavior put _tag, the failing ids and a remediation naming the tool to call next in that object; register_agent puts a code and a message in it, plus existingAgentId or expectedPrefix when the code calls for one.",
 	"An isError result means the call itself failed: invalid params (bare text in content[0].text, no structuredContent) or an unexpected crash inside the tool (structuredContent is an UnexpectedToolError envelope with ok: false and a remediation). Read the message and fix the call."
 ].join("\n");

package/tools/acceptance-metrics.js

@@ -1,11 +1,10 @@
-import { RenderText } from "../annotations.js";
-import { Effect, Schema, SchemaGetter } from "effect";
+import { Effect, Schema } from "effect";
 import { DataReader } from "@vitest-agent/engine";
 import { Tool } from "effect/unstable/ai";
 
 //#region src/tools/acceptance-metrics.ts
 const totalAnnotation = { description: "Sample size — number of observations the metric ratio is computed over." };
-const ratioAnnotation = { description: "Compliance ratio in [0, 1]. Multiply by 100 for the percentage form rendered in the markdown view." };
+const ratioAnnotation = { description: "Compliance ratio in [0, 1]. Multiply by 100 for the percentage form." };
 /**
 * The `acceptance_metrics` tool's success payload.
 *
@@ -49,19 +48,6 @@ const AcceptanceMetricsResult = Schema.Struct({
 	title: "Acceptance metrics",
 	description: "The four spec Annex A metrics computed from the current database. Each carries a sample size, a count, and a ratio."
 });
-const fmtBucket = (r) => r.total === 0 ? "no data" : `${(r.ratio * 100).toFixed(1)}% (n=${r.total})`;
-const formatAcceptanceMetricsMarkdown = (m) => [
-	"# Acceptance metrics",
-	"",
-	`1. Phase-evidence integrity: ${fmtBucket(m.phaseEvidenceIntegrity)} — target ≥80%`,
-	`2. Compliance-hook responsiveness: ${fmtBucket(m.complianceHookResponsiveness)} — target ≥40%`,
-	`3. Orientation usefulness: ${fmtBucket(m.orientationUsefulness)} — target ≥50%`,
-	`4. Anti-pattern detection rate: ${fmtBucket(m.antiPatternDetectionRate)} — target ≥95%`
-].join("\n");
-const AcceptanceMetricsAsMarkdown = AcceptanceMetricsResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform((data) => formatAcceptanceMetricsMarkdown(data)),
-	encode: SchemaGetter.forbidden(() => "AcceptanceMetricsAsMarkdown is one-way: markdown cannot be parsed back to AcceptanceMetricsResult.")
-}));
 /**
 * Handler for {@link acceptanceMetricsTool}.
 *
@@ -77,10 +63,10 @@ const handleAcceptanceMetrics = () => Effect.gen(function* () {
 * @public
 */
 const acceptanceMetricsTool = Tool.make("acceptance_metrics", {
-	description: "Use when you need the four spec Annex A acceptance metrics computed from the current database. Returns markdown in content[] and a typed JSON object in structuredContent (per-metric { total, ratio, ... }).",
+	description: "Use when you need the four spec Annex A acceptance metrics computed from the current database. Returns a typed JSON object in structuredContent (per-metric { total, ratio, ... }).",
 	success: AcceptanceMetricsResult,
 	dependencies: [DataReader]
-}).annotate(Tool.Title, "Acceptance metrics").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => formatAcceptanceMetricsMarkdown(encoded));
+}).annotate(Tool.Title, "Acceptance metrics").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
 
 //#endregion
-export { AcceptanceMetricsResult, acceptanceMetricsTool, formatAcceptanceMetricsMarkdown, handleAcceptanceMetrics };
+export { AcceptanceMetricsResult, acceptanceMetricsTool, handleAcceptanceMetrics };

package/tools/cache-health.js

@@ -1,5 +1,4 @@
-import { RenderText } from "../annotations.js";
-import { Effect, Option, Schema, SchemaGetter } from "effect";
+import { Effect, Option, Schema } from "effect";
 import { DataReader } from "@vitest-agent/engine";
 import { Tool } from "effect/unstable/ai";
 import { CacheManifest } from "@vitest-agent/sdk";
@@ -29,37 +28,6 @@ const CacheHealthResult = Schema.Union([ManifestPresent, ManifestAbsent]).annota
 	description: "Cache health snapshot. Discriminate on `manifestPresent` to see whether the manifest exists."
 });
 const STALE_AFTER_MS = 864e5;
-const iconForResult = (r) => {
-	if (r === "passed") return "✅";
-	if (r === "failed") return "❌";
-	if (r === "interrupted") return "⚠️";
-	return "⬜";
-};
-const formatCacheHealthMarkdown = (data) => {
-	const lines = ["# Cache Health", ""];
-	if (data.manifestPresent === false) {
-		lines.push("- ❌ **Manifest:** not found — run tests to populate the cache");
-		return lines.join("\n");
-	}
-	const { manifest, ageMs, stale } = data;
-	const ageHours = ageMs / 36e5;
-	lines.push("- ✅ **Manifest:** present");
-	lines.push(`- ℹ️ **Projects:** ${manifest.projects.length}`);
-	lines.push(`- ℹ️ **Cache directory:** \`${manifest.cacheDir}\``);
-	lines.push(`- ℹ️ **Last updated:** ${manifest.updatedAt}`);
-	if (stale) lines.push(`- ⚠️ **Staleness:** cache is ${Math.round(ageHours)} hours old — consider re-running tests`);
-	else lines.push(`- ✅ **Staleness:** cache is ${Math.round(ageHours * 60)} minutes old`);
-	lines.push("", "## Projects", "");
-	for (const entry of manifest.projects) {
-		const lastRun = entry.lastRun ? new Date(entry.lastRun).toLocaleString() : "never";
-		lines.push(`- ${iconForResult(entry.lastResult)} **${entry.project}** — last run: ${lastRun}`);
-	}
-	return lines.join("\n");
-};
-const CacheHealthAsMarkdown = CacheHealthResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform((data) => formatCacheHealthMarkdown(data)),
-	encode: SchemaGetter.forbidden(() => "CacheHealthAsMarkdown is one-way: markdown cannot be parsed back to CacheHealthResult.")
-}));
 /**
 * Handler for {@link cacheHealthTool}.
 *
@@ -84,10 +52,10 @@ const handleCacheHealth = () => Effect.gen(function* () {
 * @public
 */
 const cacheHealthTool = Tool.make("cache_health", {
-	description: "Use when you suspect stale data and need manifest presence, project states, and staleness. Returns markdown in content[] and a typed JSON object in structuredContent ({ manifestPresent, manifest?, ageMs?, stale? }).",
+	description: "Use when you suspect stale data and need manifest presence, project states, and staleness. Returns a typed JSON object in structuredContent ({ manifestPresent, manifest?, ageMs?, stale? }).",
 	success: CacheHealthResult,
 	dependencies: [DataReader]
-}).annotate(Tool.Title, "Cache health").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => formatCacheHealthMarkdown(encoded));
+}).annotate(Tool.Title, "Cache health").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
 
 //#endregion
-export { CacheHealthResult, cacheHealthTool, formatCacheHealthMarkdown, handleCacheHealth };
+export { CacheHealthResult, cacheHealthTool, handleCacheHealth };

package/tools/commit-changes.js

@@ -1,5 +1,4 @@
-import { RenderText } from "../annotations.js";
-import { Effect, Schema, SchemaGetter } from "effect";
+import { Effect, Schema } from "effect";
 import { DataReader } from "@vitest-agent/engine";
 import { Tool } from "effect/unstable/ai";
 
@@ -37,26 +36,6 @@ const CommitChangesResult = Schema.Struct({
 	title: "commit_changes result",
 	description: "Commit metadata + per-file changes captured by the post-commit Bash hook."
 });
-const formatCommitChangesMarkdown = (data) => {
-	if (data.commits.length === 0) return data.filterSha !== void 0 ? `No commit recorded with sha ${data.filterSha}.` : "No commits recorded yet. The PostToolUse hook on `git commit` populates this table.";
-	const lines = [];
-	for (const e of data.commits) {
-		lines.push(`## ${e.sha.slice(0, 8)} ${e.message ?? "(no message)"}`);
-		if (e.author !== null) lines.push(`- Author: ${e.author}`);
-		if (e.committedAt !== null) lines.push(`- When: ${e.committedAt}`);
-		if (e.branch !== null) lines.push(`- Branch: ${e.branch}`);
-		if (e.files.length > 0) {
-			lines.push("- Changed files:");
-			for (const f of e.files) lines.push(`  - \`${f.filePath}\` (${f.changeKind})`);
-		}
-		lines.push("");
-	}
-	return lines.join("\n").trim();
-};
-const CommitChangesAsMarkdown = CommitChangesResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform((data) => formatCommitChangesMarkdown(data)),
-	encode: SchemaGetter.forbidden(() => "CommitChangesAsMarkdown is one-way: markdown cannot be parsed back to CommitChangesResult.")
-}));
 /**
 * The `commit_changes` tool's parameters.
 *
@@ -82,11 +61,11 @@ const handleCommitChanges = (input) => Effect.gen(function* () {
 * @public
 */
 const commitChangesTool = Tool.make("commit_changes", {
-	description: "Use when you need commit metadata and changed files captured by the post-commit hook. Returns up to 20 most-recent when sha is omitted. Returns markdown in content[] and a typed JSON object in structuredContent ({ filterSha?, count, commits[] }).",
+	description: "Use when you need commit metadata and changed files captured by the post-commit hook. Returns up to 20 most-recent when sha is omitted. Returns a typed JSON object in structuredContent ({ filterSha?, count, commits[] }).",
 	parameters: CommitChangesInput,
 	success: CommitChangesResult,
 	dependencies: [DataReader]
-}).annotate(Tool.Title, "Commit changes").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => formatCommitChangesMarkdown(encoded));
+}).annotate(Tool.Title, "Commit changes").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
 
 //#endregion
-export { CommitChangesInput, CommitChangesResult, commitChangesTool, formatCommitChangesMarkdown, handleCommitChanges };
+export { CommitChangesInput, CommitChangesResult, commitChangesTool, handleCommitChanges };

package/tools/configure.js

@@ -1,5 +1,4 @@
-import { RenderText } from "../annotations.js";
-import { Effect, Option, Schema, SchemaGetter } from "effect";
+import { Effect, Option, Schema } from "effect";
 import { DataReader } from "@vitest-agent/engine";
 import { Tool } from "effect/unstable/ai";
 
@@ -41,40 +40,6 @@ const ConfigureResult = Schema.Union([SettingsFound, SettingsAbsent]).annotate({
 	title: "configure result",
 	description: "Captured Vitest settings for a run, or an absence record when the lookup found nothing."
 });
-const formatSettings = (s) => {
-	const lines = [`# Settings — \`${s.hash}\``, ""];
-	lines.push(`**Captured:** ${s.capturedAt}`);
-	if (s.project !== null) lines.push(`**Project:** ${s.project}`);
-	if (s.environment !== null) lines.push(`**Environment:** ${s.environment}`);
-	if (s.pool !== null) lines.push(`**Pool:** ${s.pool}`);
-	if (s.shard !== null) lines.push(`**Shard:** ${s.shard}`);
-	lines.push("", "## Coverage", `- **Enabled:** ${s.coverageEnabled ? "yes" : "no"}`);
-	if (s.coverageProvider !== null) lines.push(`- **Provider:** ${s.coverageProvider}`);
-	if (s.coverageThresholds !== null) lines.push(`- **Thresholds:** \`${s.coverageThresholds}\``);
-	if (s.coverageTargets !== null) lines.push(`- **Targets:** \`${s.coverageTargets}\``);
-	if (s.reporters !== null) lines.push("", "## Reporters", `\`${s.reporters}\``);
-	const envKeys = Object.keys(s.envVars);
-	if (envKeys.length > 0) {
-		lines.push("", "## Environment Variables");
-		for (const key of envKeys) lines.push(`- \`${key}\`: \`${s.envVars[key]}\``);
-	}
-	return lines.join("\n");
-};
-const formatConfigureMarkdown = (data) => {
-	if (data.found) return formatSettings(data.settings);
-	if (data.source === "latest") return [
-		"# Configure",
-		"",
-		"No settings captured yet. Run tests first.",
-		"",
-		"Configuration is written automatically by `AgentPlugin` when tests run."
-	].join("\n");
-	return `No settings found for hash \`${data.requestedHash ?? "(unknown)"}\`.`;
-};
-const ConfigureAsMarkdown = ConfigureResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform((data) => formatConfigureMarkdown(data)),
-	encode: SchemaGetter.forbidden(() => "ConfigureAsMarkdown is one-way: markdown cannot be parsed back to ConfigureResult.")
-}));
 /**
 * The `configure` tool's parameters.
 *
@@ -116,11 +81,11 @@ const handleConfigure = (input) => Effect.gen(function* () {
 * @public
 */
 const configureTool = Tool.make("configure", {
-	description: "Use when you need the captured Vitest settings for a test run. Returns markdown in content[] and a typed JSON object in structuredContent ({ found, source, settings?, requestedHash? }).",
+	description: "Use when you need the captured Vitest settings for a test run. Returns a typed JSON object in structuredContent ({ found, source, settings?, requestedHash? }).",
 	parameters: ConfigureInput,
 	success: ConfigureResult,
 	dependencies: [DataReader]
-}).annotate(Tool.Title, "Configure").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => formatConfigureMarkdown(encoded));
+}).annotate(Tool.Title, "Configure").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
 
 //#endregion
-export { ConfigureInput, ConfigureResult, configureTool, formatConfigureMarkdown, handleConfigure };
+export { ConfigureInput, ConfigureResult, configureTool, handleConfigure };

package/tools/coverage.js

@@ -1,5 +1,4 @@
-import { RenderText } from "../annotations.js";
-import { Effect, Option, Schema, SchemaGetter } from "effect";
+import { Effect, Option, Schema } from "effect";
 import { DataReader } from "@vitest-agent/engine";
 import { Tool } from "effect/unstable/ai";
 import { CoverageReport } from "@vitest-agent/sdk";
@@ -24,55 +23,6 @@ const TestCoverageResult = Schema.Union([CoverageAvailable, CoverageAbsent]).ann
 	title: "test_coverage result",
 	description: "Per-project coverage report. Discriminate on `dataAvailable` for cold-start handling."
 });
-const METRICS = [
-	"statements",
-	"branches",
-	"functions",
-	"lines"
-];
-/** @internal */
-const renderFileCoverageTable = (fileCoverage) => {
-	const rows = [
-		`### \`${fileCoverage.file}\``,
-		"",
-		"| Metric | Value |",
-		"| --- | --- |"
-	];
-	for (const metric of METRICS) rows.push(`| ${metric} | ${fileCoverage.summary[metric].toFixed(2)}% |`);
-	if (fileCoverage.uncoveredLines) rows.push(`| Uncovered lines | \`${fileCoverage.uncoveredLines}\` |`);
-	rows.push("");
-	return rows;
-};
-const formatTestCoverageMarkdown = (data) => {
-	if (!data.dataAvailable) return "No coverage data available. Run tests with coverage enabled.";
-	const lines = ["# Coverage Report", ""];
-	const { totals, thresholds, targets } = data.coverage;
-	const headerCols = targets ? "| Metric | Value | Enforced threshold | Target |" : "| Metric | Value | Enforced threshold |";
-	const sepCols = targets ? "| --- | --- | --- | --- |" : "| --- | --- | --- |";
-	lines.push("## Totals", "", headerCols, sepCols);
-	for (const metric of METRICS) {
-		const value = totals[metric];
-		const threshold = thresholds.global[metric];
-		const thresholdStr = threshold !== void 0 ? `${threshold}%` : "—";
-		const icon = threshold !== void 0 && value < threshold ? "❌" : "✅";
-		const targetStr = targets ? targets.global[metric] !== void 0 ? `${targets.global[metric]}%` : "—" : void 0;
-		lines.push(`| ${metric} | ${icon} ${value.toFixed(2)}% | ${thresholdStr} |${targetStr !== void 0 ? ` ${targetStr} |` : ""}`);
-	}
-	lines.push("");
-	if (data.coverage.lowCoverage.length > 0) {
-		lines.push("## Coverage Gaps", "", "Files below the enforced threshold (build-blocking):", "");
-		for (const fileCoverage of data.coverage.lowCoverage) lines.push(...renderFileCoverageTable(fileCoverage));
-	} else lines.push("✅ All files meet coverage thresholds.", "");
-	if (data.coverage.belowTarget && data.coverage.belowTarget.length > 0) {
-		lines.push("## Coverage Improvements Needed", "", "Files below the aspirational target (passing the enforced threshold):", "");
-		for (const fileCoverage of data.coverage.belowTarget) lines.push(...renderFileCoverageTable(fileCoverage));
-	}
-	return lines.join("\n");
-};
-const TestCoverageAsMarkdown = TestCoverageResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform((data) => formatTestCoverageMarkdown(data)),
-	encode: SchemaGetter.forbidden(() => "TestCoverageAsMarkdown is one-way.")
-}));
 /**
 * The `test_coverage` tool's parameters.
 *
@@ -104,11 +54,11 @@ const handleTestCoverage = (input) => Effect.gen(function* () {
 * @public
 */
 const testCoverageTool = Tool.make("test_coverage", {
-	description: "Use when coverage drops and you need per-metric gap analysis against thresholds and targets. Returns markdown in content[] and a typed JSON object in structuredContent ({ dataAvailable, project, coverage } or absent variant).",
+	description: "Use when coverage drops and you need per-metric gap analysis against thresholds and targets. Returns a typed JSON object in structuredContent ({ dataAvailable, project, coverage } or absent variant).",
 	parameters: TestCoverageInput,
 	success: TestCoverageResult,
 	dependencies: [DataReader]
-}).annotate(Tool.Title, "Test coverage").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => formatTestCoverageMarkdown(encoded));
+}).annotate(Tool.Title, "Test coverage").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
 
 //#endregion
-export { TestCoverageInput, TestCoverageResult, formatTestCoverageMarkdown, handleTestCoverage, testCoverageTool };
+export { TestCoverageInput, TestCoverageResult, handleTestCoverage, testCoverageTool };