@vitest-agent/mcp 4.2.2 → 4.3.1

package/tools/run-tests.js

@@ -1,7 +1,6 @@
-import { RenderText } from "../annotations.js";
 import { McpSession } from "../session.js";
 import { createRequire } from "node:module";
-import { Data, Effect, Schema, SchemaGetter, Semaphore } from "effect";
+import { Data, Effect, Schema, Semaphore } from "effect";
 import { DataReader, DataStore } from "@vitest-agent/engine";
 import { Tool } from "effect/unstable/ai";
 import { AgentReport, buildAgentReport, buildConsoleLeaks, coerceErrorField, collectConsoleLeakEntries, formatScopedCoverageNote } from "@vitest-agent/sdk";
@@ -386,131 +385,6 @@ function coerceErrors(errors) {
 	});
 }
 /**
-* Render the full structured `RunTestsResult` as markdown for the
-* text channel. Discriminates on `kind` then defers to the existing
-* AgentReport rendering for the `ok` case.
-*/
-function formatRunTestsMarkdown(data) {
-	if (data.kind === "timeout") return `Test run timed out after ${data.timeoutSeconds} seconds.`;
-	if (data.kind === "error") return `Test run failed: ${data.message}`;
-	const rootLine = `\nProject root: \`${data.projectRoot}\``;
-	if (data.kind === "no-match") return `${formatNoMatchMarkdown(data.filter)}${rootLine}`;
-	const classMap = new Map(Object.entries(data.classifications));
-	return `${formatReportMarkdown(data.report, classMap, data.scopedNote ?? void 0)}${rootLine}`;
-}
-/**
-* Render the `no-match` filter context plus a remediation pointer aimed at
-* tag introspection. Pure helper; called by {@link formatRunTestsMarkdown}.
-*
-* @internal
-*/
-function formatNoMatchMarkdown(filter) {
-	const lines = ["## No tests matched the filter", ""];
-	const parts = [];
-	if (filter.project !== null) parts.push(`project: \`${filter.project}\``);
-	if (filter.files.length > 0) parts.push(`files: ${filter.files.map((f) => `\`${f}\``).join(", ")}`);
-	if (filter.tags !== null) {
-		const t = filter.tags;
-		if (t.all && t.all.length > 0) parts.push(`tags.all: ${t.all.map((s) => `\`${s}\``).join(", ")}`);
-		if (t.any && t.any.length > 0) parts.push(`tags.any: ${t.any.map((s) => `\`${s}\``).join(", ")}`);
-		if (t.none && t.none.length > 0) parts.push(`tags.none: ${t.none.map((s) => `\`${s}\``).join(", ")}`);
-	}
-	if (filter.resolvedExpression !== null) parts.push(`resolved expression: \`${filter.resolvedExpression}\``);
-	if (parts.length === 0) lines.push("- (no filter recorded)");
-	else for (const p of parts) lines.push(`- ${p}`);
-	lines.push("");
-	lines.push("### Next steps");
-	if (filter.tags !== null) {
-		lines.push("- Confirm the tag exists: `inventory({ kind: \"tag\" })`");
-		lines.push("- List tests for a specific tag: `test({ action: \"for_tag\", tag: \"<name>\" })`");
-	}
-	if (filter.files.length > 0) lines.push("- Verify file paths exist or list tests in a file with `test({ action: \"for_file\", filePath })`");
-	if (filter.project !== null) lines.push("- Verify the project name with `inventory({ kind: \"project\" })`");
-	return lines.join("\n");
-}
-const RunTestsAsMarkdown = RunTestsResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform((data) => formatRunTestsMarkdown(data)),
-	encode: SchemaGetter.forbidden(() => "RunTestsAsMarkdown is one-way.")
-}));
-/**
-* Format an AgentReport as concise markdown suitable for MCP tool output.
-*
-* Classifications map test fullName to labels like "new-failure",
-* "persistent", "flaky", "recovered", "stable". Populated from DB
-* after the reporter writes history.
-*
-* @internal
-*/
-function formatReportMarkdown(report, classifications, scopedNote) {
-	const lines = [];
-	const { summary } = report;
-	const collectionFailedFiles = report.failed.filter((m) => m.errors !== void 0 && m.errors.length > 0 && !m.tests.some((t) => t.state === "failed")).map((m) => m.file);
-	const hasCollectionFailures = collectionFailedFiles.length > 0;
-	const isFailing = summary.failed > 0 || report.unhandledErrors.length > 0 || hasCollectionFailures;
-	const status = isFailing ? "❌" : "✅";
-	const headlineParts = [];
-	if (summary.failed > 0) headlineParts.push(`${summary.failed} failed`);
-	if (hasCollectionFailures) headlineParts.push(`${collectionFailedFiles.length} failed to load`);
-	headlineParts.push(`${summary.passed} passed`);
-	if (summary.skipped > 0) headlineParts.push(`${summary.skipped} skipped`);
-	lines.push(`## ${status} Vitest -- ${headlineParts.join(", ")} (${summary.duration}ms)`);
-	if (report.project) lines.push(`\nProject: ${report.project}`);
-	if (scopedNote !== void 0) lines.push(`\n${scopedNote}`);
-	if (report.consoleLeaks !== void 0) {
-		const cl = report.consoleLeaks;
-		if (cl.total > 0) {
-			const writes = `${cl.total} stray console write${cl.total === 1 ? "" : "s"}`;
-			const plural = cl.byFile.length !== 1 || cl.truncated === true;
-			const files = `${cl.byFile.length}${cl.truncated === true ? "+" : ""} file${plural ? "s" : ""}`;
-			lines.push(`\n⚠ ${writes} across ${files} (see consoleLeaks)`);
-		}
-		if (cl.fromFailingTests !== void 0) {
-			const { total: failingTotal } = cl.fromFailingTests;
-			lines.push(`\n${failingTotal} console write${failingTotal === 1 ? "" : "s"} from failing tests (not counted as leaks)`);
-		}
-	}
-	for (const mod of report.failed) {
-		lines.push(`\n### \u274C \`${mod.file}\``);
-		if (mod.errors) for (const err of mod.errors) {
-			lines.push(`\n- \u274C **Module failed to load**: ${err.message}`);
-			if (err.stack) lines.push(`\n  \`\`\`\n  ${err.stack}\n  \`\`\``);
-		}
-		for (const test of mod.tests) {
-			if (test.state !== "failed") continue;
-			const badge = classifications?.get(test.fullName);
-			const label = badge ? ` [${badge}]` : "";
-			lines.push(`\n- \u274C **${test.fullName}**${label}`);
-			if (test.errors) for (const err of test.errors) {
-				lines.push(`  ${err.message}`);
-				if (err.diff) {
-					const diff = err.diff.length > 1e3 ? `${err.diff.slice(0, 1e3)}\n... (truncated, ${err.diff.length} chars total)` : err.diff;
-					lines.push(`\n  \`\`\`diff\n  ${diff}\n  \`\`\``);
-				}
-			}
-		}
-	}
-	if (report.unhandledErrors.length > 0) {
-		lines.push("\n### Unhandled Errors");
-		for (const err of report.unhandledErrors) {
-			lines.push(`\n- ${err.message}`);
-			if (err.stack) lines.push(`  \`\`\`\n  ${err.stack}\n  \`\`\``);
-		}
-	}
-	if (isFailing) {
-		const newFailures = classifications ? [...classifications.values()].filter((c) => c === "new-failure").length : 0;
-		const persistent = classifications ? [...classifications.values()].filter((c) => c === "persistent").length : 0;
-		const flaky = classifications ? [...classifications.values()].filter((c) => c === "flaky").length : 0;
-		lines.push("\n### Next steps\n");
-		if (newFailures > 0) lines.push(`- ${newFailures} new failure${newFailures > 1 ? "s" : ""} since last run`);
-		if (persistent > 0) lines.push(`- ${persistent} persistent failure${persistent > 1 ? "s" : ""} (pre-existing)`);
-		if (flaky > 0) lines.push(`- ${flaky} flaky test${flaky > 1 ? "s" : ""} -- consider retrying`);
-		lines.push("- Use test_errors for detailed error analysis");
-		lines.push("- Use test_history to check failure patterns");
-		if (report.failedFiles.length > 0) lines.push(`- Re-run failed: run_tests({ files: ${JSON.stringify(report.failedFiles)} })`);
-	}
-	return lines.join("\n");
-}
-/**
 * The `run_tests` tool's parameters. `tags` and `_sessionContext` are
 * nested structs and are served strict at their own level (issue #243).
 *
@@ -738,7 +612,7 @@ const runTestsTool = Tool.make("run_tests", {
 		DataReader,
 		DataStore
 	]
-}).annotate(Tool.Title, "Run tests").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, false).annotate(RenderText, (encoded) => formatRunTestsMarkdown(encoded));
+}).annotate(Tool.Title, "Run tests").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, false);
 
 //#endregion
-export { RunTestsInput, RunTestsResult, coerceErrors, composeTagExpression, formatNoMatchMarkdown, formatReportMarkdown, formatRunTestsMarkdown, handleRunTests, makeBestEffortFork, makeCoverageDirOverride, readDiscoveryLastScannedAt, resolveAnchoredConfigFile, resolveConfigAnchoredRoot, resolveGitCommonDir, resolveVitestNodeEntry, runTestsTool, sanitizeTestArgs, validateProjectRoot, vitestLoader, withStdioCaptured };
+export { RunTestsInput, RunTestsResult, coerceErrors, composeTagExpression, handleRunTests, makeBestEffortFork, makeCoverageDirOverride, readDiscoveryLastScannedAt, resolveAnchoredConfigFile, resolveConfigAnchoredRoot, resolveGitCommonDir, resolveVitestNodeEntry, runTestsTool, sanitizeTestArgs, validateProjectRoot, vitestLoader, withStdioCaptured };

package/tools/settings-list.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";
 
@@ -21,21 +20,6 @@ const SettingsListResult = Schema.Struct({
 	title: "settings_list result",
 	description: "Roster of distinct Vitest settings hashes the reporter has captured."
 });
-const formatSettingsListMarkdown = (data) => {
-	if (data.settings.length === 0) return "No settings found. Run tests first.";
-	const lines = [
-		"## Settings",
-		"",
-		"| Hash | Timestamp |",
-		"| --- | --- |"
-	];
-	for (const s of data.settings) lines.push(`| ${s.hash} | ${s.capturedAt} |`);
-	return lines.join("\n");
-};
-const SettingsListAsMarkdown = SettingsListResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform((data) => formatSettingsListMarkdown(data)),
-	encode: SchemaGetter.forbidden(() => "SettingsListAsMarkdown is one-way.")
-}));
 /**
 * Handler for {@link settingsListTool}.
 *
@@ -55,10 +39,10 @@ const handleSettingsList = () => Effect.gen(function* () {
 * @public
 */
 const settingsListTool = Tool.make("settings_list", {
-	description: "Use when you need every captured settings snapshot and its hash. Returns markdown in content[] and a typed JSON object in structuredContent ({ count, settings[] }).",
+	description: "Use when you need every captured settings snapshot and its hash. Returns a typed JSON object in structuredContent ({ count, settings[] }).",
 	success: SettingsListResult,
 	dependencies: [DataReader]
-}).annotate(Tool.Title, "Settings list").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => formatSettingsListMarkdown(encoded));
+}).annotate(Tool.Title, "Settings list").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
 
 //#endregion
-export { SettingsListResult, formatSettingsListMarkdown, handleSettingsList, settingsListTool };
+export { SettingsListResult, handleSettingsList, settingsListTool };

package/tools/status.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 { CacheManifestEntry } from "@vitest-agent/sdk";
@@ -26,29 +25,6 @@ const TestStatusResult = Schema.Union([StatusAvailable, StatusAbsent]).annotate(
 	title: "test_status result",
 	description: "Per-project last-run summary. Discriminate on `dataAvailable` for cold-start handling."
 });
-const iconForResult = (r) => {
-	if (r === "passed") return "✅";
-	if (r === "failed") return "❌";
-	if (r === "interrupted") return "⚠️";
-	return "⬜";
-};
-const formatTestStatusMarkdown = (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 Status", ""];
-	for (const entry of data.entries) {
-		const lastRun = entry.lastRun ? new Date(entry.lastRun).toLocaleString() : "never";
-		lines.push(`- ${iconForResult(entry.lastResult)} **${entry.project}** — last run: ${lastRun}, result: ${entry.lastResult ?? "unknown"}`);
-	}
-	lines.push("", `_Cache updated: ${data.manifestUpdatedAt}_`);
-	return lines.join("\n");
-};
-const TestStatusAsMarkdown = TestStatusResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform((data) => formatTestStatusMarkdown(data)),
-	encode: SchemaGetter.forbidden(() => "TestStatusAsMarkdown is one-way.")
-}));
 /**
 * The `test_status` tool's parameters.
 *
@@ -88,11 +64,11 @@ const handleTestStatus = (input) => Effect.gen(function* () {
 * @public
 */
 const testStatusTool = Tool.make("test_status", {
-	description: "Use when you need each project's current pass/fail state from the most recent run. Returns markdown in content[] and a typed JSON object in structuredContent ({ dataAvailable, manifestUpdatedAt, projectFilter?, entries[] } or absent variant).",
+	description: "Use when you need each project's current pass/fail state from the most recent run. Returns a typed JSON object in structuredContent ({ dataAvailable, manifestUpdatedAt, projectFilter?, entries[] } or absent variant).",
 	parameters: TestStatusInput,
 	success: TestStatusResult,
 	dependencies: [DataReader]
-}).annotate(Tool.Title, "Test status").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => formatTestStatusMarkdown(encoded));
+}).annotate(Tool.Title, "Test status").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
 
 //#endregion
-export { TestStatusInput, TestStatusResult, formatTestStatusMarkdown, handleTestStatus, testStatusTool };
+export { TestStatusInput, TestStatusResult, handleTestStatus, testStatusTool };

package/tools/tdd-artifact.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";
 
@@ -57,29 +56,6 @@ const TddArtifactListResult = Schema.Struct({
 	title: "tdd_artifact_list result",
 	description: "Newest-first artifact rows for a TDD task. Echoes the filters that were applied so callers can reason about what is/isn't included."
 });
-const describeFilters = (filters) => {
-	const parts = [];
-	if (filters.artifactKind !== void 0) parts.push(`artifactKind=${filters.artifactKind}`);
-	if (filters.phaseId !== void 0) parts.push(`phaseId=${filters.phaseId}`);
-	if (filters.behaviorId !== void 0) parts.push(`behaviorId=${filters.behaviorId}`);
-	return parts.length > 0 ? ` matching ${parts.join(", ")}` : "";
-};
-const formatTddArtifactListMarkdown = (data) => {
-	if (data.count === 0) return `No artifacts recorded for tdd_task ${data.tddTaskId}${describeFilters(data.filters)}.`;
-	const lines = [`# Artifacts for tdd_task ${data.tddTaskId} (newest first, ${data.count} shown)`, ""];
-	for (const r of data.artifacts) {
-		const extras = [`phase=${r.phaseName} [phaseId=${r.phaseId}]`, `suite=${r.suite}`];
-		if (r.behaviorId !== null) extras.push(`behaviorId=${r.behaviorId}`);
-		if (r.testCaseId !== null) extras.push(`testCaseId=${r.testCaseId}`);
-		if (r.testRunId !== null) extras.push(`testRunId=${r.testRunId}`);
-		lines.push(`- **${r.artifactKind}** [id=${r.id}] at=${r.recordedAt} ${extras.join(" ")}`);
-	}
-	return lines.join("\n");
-};
-const TddArtifactListAsMarkdown = TddArtifactListResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform((data) => formatTddArtifactListMarkdown(data)),
-	encode: SchemaGetter.forbidden(() => "TddArtifactListAsMarkdown is one-way.")
-}));
 /**
 * The `tdd_artifact_list` tool's parameters.
 *
@@ -126,7 +102,7 @@ const tddArtifactListTool = Tool.make("tdd_artifact_list", {
 	parameters: TddArtifactListInput,
 	success: TddArtifactListResult,
 	dependencies: [DataReader]
-}).annotate(Tool.Title, "TDD artifact list").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => formatTddArtifactListMarkdown(encoded));
+}).annotate(Tool.Title, "TDD artifact list").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
 
 //#endregion
-export { TddArtifactListInput, TddArtifactListResult, formatTddArtifactListMarkdown, handleTddArtifactList, tddArtifactListTool };
+export { TddArtifactListInput, TddArtifactListResult, handleTddArtifactList, tddArtifactListTool };

package/tools/tdd-phase-transition-request.js

@@ -1,4 +1,3 @@
-import { RenderText } from "../annotations.js";
 import { Effect, Option, Schema } from "effect";
 import { DataReader, DataStore } from "@vitest-agent/engine";
 import { Tool } from "effect/unstable/ai";
@@ -294,7 +293,7 @@ const tddPhaseTransitionRequestTool = Tool.make("tdd_phase_transition_request",
 	parameters: PhaseTransitionInput,
 	success: PhaseTransitionResult,
 	dependencies: [DataReader, DataStore]
-}).annotate(Tool.Title, "TDD phase transition request").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => JSON.stringify(encoded, null, 2));
+}).annotate(Tool.Title, "TDD phase transition request").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
 
 //#endregion
 export { PhaseTransitionInput, PhaseTransitionResult, handlePhaseTransitionRequest, tddPhaseTransitionRequestTool };

package/tools/tdd-progress-push.js

@@ -1,4 +1,3 @@
-import { RenderText } from "../annotations.js";
 import { Effect, Option, Schema } from "effect";
 import { DataReader } from "@vitest-agent/engine";
 import { McpServer, Tool } from "effect/unstable/ai";
@@ -96,7 +95,7 @@ const tddProgressPushTool = Tool.make("tdd_progress_push", {
 	parameters: TddProgressPushInput,
 	success: TddProgressPushResult,
 	dependencies: [DataReader, McpServer.McpServer]
-}).annotate(Tool.Title, "TDD progress push").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, false).annotate(RenderText, (encoded) => JSON.stringify(encoded, null, 2));
+}).annotate(Tool.Title, "TDD progress push").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, false);
 
 //#endregion
 export { CHANNEL_LOGGER, TddProgressPushInput, TddProgressPushResult, handleTddProgressPush, resolveChannelEvent, tddProgressPushTool };

package/tools/tdd-task.js

@@ -1,6 +1,5 @@
-import { RenderText } from "../annotations.js";
 import { IdempotentReplayMarker } from "../utils/replay-marker.js";
-import { Effect, Match, Option, Schema, SchemaGetter } from "effect";
+import { Effect, Match, Option, Schema } from "effect";
 import { DataReader, DataStore } from "@vitest-agent/engine";
 import { Tool } from "effect/unstable/ai";
 import { GoalDetail } from "@vitest-agent/sdk";
@@ -95,65 +94,6 @@ const TddTaskResult = Schema.Union([
 	title: "tdd_task result",
 	description: "Discriminate on `action`. `get` and `resume` further discriminate on `found`. `get` carries the full nested task tree."
 });
-const formatTddTaskMarkdown = (data) => {
-	if (data.action === "start" || data.action === "end") return JSON.stringify(data, null, 2);
-	if (data.action === "get") {
-		if (!data.found) return `No TDD task with tddTaskId=${data.tddTaskId}.`;
-		const s = data.task;
-		const currentPhaseLine = data.currentPhase === null ? "- current phase: (none — no open phase)" : `- current phase: ${data.currentPhase.phase} [phaseId=${data.currentPhase.id}]${data.currentPhase.behaviorId !== null ? ` behaviorId=${data.currentPhase.behaviorId}` : ""}`;
-		const lines = [
-			`# TDD Task ${s.tddTaskId}`,
-			"",
-			`- goal: ${s.goal}`,
-			`- run_id: ${s.runId ?? "(none — run_id not recorded)"}`,
-			`- sessionId: ${s.sessionId}`,
-			`- started: ${s.startedAt}`,
-			`- ended: ${s.endedAt ?? "still open"}`,
-			`- outcome: ${s.outcome ?? "pending"}`,
-			currentPhaseLine
-		];
-		if (s.phases.length > 0) {
-			lines.push("", "## Phases", "");
-			for (const p of s.phases) {
-				const duration = p.endedAt ? ` -> ${p.endedAt}` : " (current)";
-				lines.push(`- **${p.phase}** [id=${p.id}] ${p.startedAt}${duration}`);
-				if (p.transitionReason !== null) lines.push(`  - reason: ${p.transitionReason}`);
-			}
-		}
-		if (s.artifacts.length > 0) {
-			lines.push("", "## Artifacts", "");
-			for (const a of s.artifacts) lines.push(`- **${a.artifactKind}** [id=${a.id}, phase=${a.phaseId}] at=${a.recordedAt}${a.testRunId !== null ? ` run=${a.testRunId}` : ""}`);
-		}
-		if (s.goals.length > 0) {
-			lines.push("", "## Goals and Behaviors", "");
-			for (const g of s.goals) {
-				lines.push(`### Goal ${g.ordinal + 1}: ${g.goal} [${g.status}]`);
-				if (g.behaviors.length > 0) {
-					lines.push("");
-					for (const b of g.behaviors) lines.push(`- **${b.behavior}** [${b.status}]`);
-				}
-				lines.push("");
-			}
-		}
-		return lines.join("\n");
-	}
-	if (!data.found) return `No TDD task with tddTaskId=${data.tddTaskId}.`;
-	const lines = [
-		`# TDD task #${data.tddTaskId}: ${data.goal}`,
-		"",
-		`**Status:** ${data.status}`
-	];
-	if (data.currentPhase !== null) lines.push(`**Current phase:** ${data.currentPhase.phase} (started ${data.currentPhase.startedAt})`);
-	else lines.push("**Current phase:** none (TDD cycle not yet entered)");
-	lines.push("", `**Phases recorded:** ${data.phasesRecorded}`);
-	if (data.artifactsRecorded > 0) lines.push(`**Artifacts:** ${data.artifactsRecorded}`);
-	lines.push("", `Use \`tdd_task({ action: "get", tddTaskId: ${data.tddTaskId} })\` for the full detail tree, or call \`tdd_phase_transition_request\` to advance.`);
-	return lines.join("\n");
-};
-const TddTaskAsMarkdown = TddTaskResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform((data) => formatTddTaskMarkdown(data)),
-	encode: SchemaGetter.forbidden(() => "TddTaskAsMarkdown is one-way.")
-}));
 const StartVariant = Schema.Struct({
 	action: Schema.Literal("start").annotate({ description: "Lifecycle discriminator" }),
 	goal: Schema.String.annotate({ description: "start: goal text" }),
@@ -301,11 +241,11 @@ const handleTddTask = (input) => Match.value(input).pipe(Match.discriminatorsExh
 * @public
 */
 const tddTaskTool = Tool.make("tdd_task", {
-	description: "Use to manage a TDD task lifecycle, with an action discriminator: action='start' (goal, sessionId|chatId, parentTddTaskId?, startedAt?, runId?) opens a new task; action='end' (tddTaskId, outcome, summaryNoteId?) closes one; action='get' (tddTaskId) returns markdown details; action='resume' (tddTaskId) returns a compact digest.",
+	description: "Use to manage a TDD task lifecycle, with an action discriminator: action='start' (goal, sessionId|chatId, parentTddTaskId?, startedAt?, runId?) opens a new task; action='end' (tddTaskId, outcome, summaryNoteId?) closes one; action='get' (tddTaskId) returns the full task detail; action='resume' (tddTaskId) returns a compact digest.",
 	parameters: TddTaskInput,
 	success: TddTaskResult,
 	dependencies: [DataReader, DataStore]
-}).annotate(Tool.Title, "TDD task").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => formatTddTaskMarkdown(encoded));
+}).annotate(Tool.Title, "TDD task").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
 
 //#endregion
-export { TddTaskInput, TddTaskResult, formatTddTaskMarkdown, handleTddTask, tddTaskTool };
+export { TddTaskInput, TddTaskResult, handleTddTask, tddTaskTool };

package/tools/test.js

@@ -1,6 +1,5 @@
-import { RenderText } from "../annotations.js";
 import { collectProjectRows, resolveProjectTargets } from "./_project-groups.js";
-import { Effect, Match, Option, Schema, SchemaGetter } from "effect";
+import { Effect, Match, Option, Schema } from "effect";
 import { DataReader } from "@vitest-agent/engine";
 import { Tool } from "effect/unstable/ai";
 
@@ -163,147 +162,6 @@ const TestResult = Schema.Union([
 	title: "test result",
 	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") {
-		if (data.count === 0) return "No tests found. Run run_tests({}) to execute tests and populate the database.";
-		const lines = ["## Tests", ""];
-		for (const g of data.groups) {
-			lines.push(`### ${g.project}`, "", "| ID | Full Name | State | Duration | Module | Classification |", "| --- | --- | --- | --- | --- | --- |");
-			for (const t of g.tests) {
-				const duration = t.duration !== null ? `${t.duration}ms` : "—";
-				const classification = t.classification ?? "—";
-				lines.push(`| ${t.id} | ${t.fullName} | ${t.state} | ${duration} | ${t.module} | ${classification} |`);
-			}
-			lines.push("");
-		}
-		return lines.join("\n").trimEnd();
-	}
-	if (data.action === "get") {
-		if (!data.found) {
-			if (data.ambiguous === true) {
-				const modules = data.candidateModules ?? [];
-				return [
-					`Ambiguous test name: \`${data.fullName}\` matches ${modules.length} modules in project \`${data.project}\`.`,
-					"",
-					...modules.map((m) => `- \`${m}\``),
-					"",
-					`Re-run with a modulePath, e.g. test({ action: "get", fullName: "${data.fullName}", modulePath: "${modules[0] ?? ""}" }).`
-				].join("\n");
-			}
-			return `Test not found: \`${data.fullName}\`\n\nUse test({ action: "list" }) to discover available tests (format: "Suite > test name").`;
-		}
-		const t = data.test;
-		const lines = [
-			`# Test: ${t.fullName}`,
-			"",
-			"## Details",
-			"",
-			"| Field | Value |",
-			"| --- | --- |",
-			`| State | ${t.state} |`,
-			`| Duration | ${t.duration !== null ? `${t.duration}ms` : "—"} |`,
-			`| Module | \`${t.module}\` |`,
-			`| Classification | ${t.classification ?? "—"} |`,
-			""
-		];
-		if (data.errors.length > 0) {
-			lines.push("## Errors", "");
-			for (const err of data.errors) {
-				lines.push(`**${err.name ?? "(unnamed)"}**`);
-				lines.push(`> ${err.message.split("\n").join("\n> ")}`);
-				if (err.diff !== null) {
-					lines.push("", "```diff", err.diff.slice(0, 1e3));
-					if (err.diff.length > 1e3) lines.push(`... (truncated, ${err.diff.length} chars total)`);
-					lines.push("```");
-				}
-				if (err.stack !== null && err.diff === null) {
-					lines.push("", "```", err.stack.slice(0, 1e3));
-					if (err.stack.length > 1e3) lines.push(`... (truncated, ${err.stack.length} chars total)`);
-					lines.push("```");
-				}
-				lines.push("");
-			}
-		}
-		if (data.runs.length > 0) {
-			const viz = data.runs.map((r) => r.state === "passed" ? "P" : "F").join("");
-			const passCount = data.runs.filter((r) => r.state === "passed").length;
-			const failCount = data.runs.filter((r) => r.state === "failed").length;
-			lines.push("## Run History", "", `Pass rate: ${passCount}/${data.runs.length} (${Math.round(passCount / data.runs.length * 100)}%)`, `Recent runs: \`${viz}\` (P=passed F=failed S=skipped, newest last)`);
-			if (failCount > 0 && passCount > 0) lines.push("Pattern: **flaky** (mixed pass/fail)");
-			else if (failCount > 0) lines.push(`Pattern: **persistent failure** (${failCount} consecutive)`);
-			lines.push("");
-		}
-		if (t.state === "failed") lines.push("## Next steps", "", `- Re-run: run_tests({ files: ["${t.module}"] })`, `- Use test({ action: "for_file", filePath: "${t.module}" }) to find related tests`, "- Use note({ action: \"create\", ... }) to record debugging findings");
-		return lines.join("\n");
-	}
-	if (data.action === "for_tag") {
-		if (data.count === 0) return `No tests found tagged \`${data.tag}\`. Use \`inventory({ kind: "tag" })\` to discover available tags.`;
-		const lines = [
-			`# Tests tagged \`${data.tag}\``,
-			"",
-			`Found ${data.count} test${data.count === 1 ? "" : "s"} across ${data.groups.length} project${data.groups.length === 1 ? "" : "s"}:`,
-			""
-		];
-		for (const g of data.groups) {
-			lines.push(`### ${g.project}`, "", "| ID | Full Name | State | Duration | Module |", "| --- | --- | --- | --- | --- |");
-			for (const t of g.tests) {
-				const duration = t.duration !== null ? `${t.duration}ms` : "—";
-				lines.push(`| ${t.id} | ${t.fullName} | ${t.state} | ${duration} | ${t.module} |`);
-			}
-			lines.push("");
-		}
-		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}\``,
-		"",
-		`Found ${data.count} test module${data.count === 1 ? "" : "s"}:`,
-		""
-	];
-	for (const f of data.testFiles) lines.push(`- \`${f}\``);
-	return lines.join("\n");
-};
-const TestAsMarkdown = TestResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform((data) => formatTestMarkdown(data)),
-	encode: SchemaGetter.forbidden(() => "TestAsMarkdown is one-way.")
-}));
 const ListVariant = Schema.Struct({
 	action: Schema.Literal("list"),
 	project: Schema.optionalKey(Schema.String),
@@ -482,7 +340,7 @@ const testTool = Tool.make("test", {
 	parameters: TestInput,
 	success: TestResult,
 	dependencies: [DataReader]
-}).annotate(Tool.Title, "Test").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => formatTestMarkdown(encoded));
+}).annotate(Tool.Title, "Test").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
 
 //#endregion
-export { TestInput, TestResult, formatTestMarkdown, handleTest, testTool };
+export { TestInput, TestResult, handleTest, testTool };