@vitest-agent/mcp 4.2.1 → 4.3.0

package/tools/errors.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";
 
@@ -63,84 +62,6 @@ const TestErrorsResult = Schema.Struct({
 	title: "test_errors result",
 	description: "Structured payload of the `test_errors` MCP tool. Carries the cite-able test_errors.id and stack_frames.id values agents need for `hypothesis (action: record)`."
 });
-const TRUNCATION_LIMIT = 500;
-const truncate = (s) => s.length <= TRUNCATION_LIMIT ? {
-	value: s,
-	truncated: false
-} : {
-	value: s.slice(0, TRUNCATION_LIMIT),
-	truncated: true
-};
-/**
-* Pure markdown renderer. Exposed so the formatter tests can exercise
-* it without rebuilding a `Schema.encode` runtime.
-*/
-const formatTestErrorsMarkdown = (data) => {
-	if (data.errors.length === 0) return `No errors found for project \`${data.project}\`.`;
-	const lines = [`# Test Errors — ${data.project}`, ""];
-	for (const error of data.errors) {
-		const name = error.name ?? "(unnamed)";
-		const idTokens = `[testErrorId=${error.id}${error.topStackFrameId !== null ? ` topStackFrameId=${error.topStackFrameId}` : ""}]`;
-		lines.push(`## ${name} ${idTokens}`);
-		lines.push("");
-		lines.push(`**Scope:** ${error.scope}`);
-		if (error.testFullName !== null) lines.push(`**Test:** ${error.testFullName}`);
-		if (error.moduleFile !== null) lines.push(`**File:** \`${error.moduleFile}\``);
-		if (error.annotations.length > 0) {
-			lines.push("**Annotations:**");
-			for (const annotation of error.annotations) lines.push(`- [${annotation.type}] ${annotation.message}`);
-		}
-		lines.push("");
-		lines.push("**Cite-able IDs (for `hypothesis (action: record)`):**");
-		lines.push(`- citedTestErrorId: ${error.id}`);
-		if (error.topStackFrameId !== null) lines.push(`- citedStackFrameId: ${error.topStackFrameId}`);
-		else lines.push("- citedStackFrameId: (none — no stack frames recorded for this error)");
-		lines.push("");
-		lines.push("**Message:**");
-		lines.push(`> ${error.message.split("\n").join("\n> ")}`);
-		if (error.diff !== null) {
-			lines.push("");
-			lines.push("**Diff:**");
-			lines.push("```diff");
-			const t = truncate(error.diff);
-			lines.push(t.value);
-			if (t.truncated) lines.push("... (truncated)");
-			lines.push("```");
-		}
-		if (error.stack !== null && error.diff === null) {
-			lines.push("");
-			lines.push("**Stack:**");
-			lines.push("```");
-			const t = truncate(error.stack);
-			lines.push(t.value);
-			if (t.truncated) lines.push("... (truncated)");
-			lines.push("```");
-		}
-		lines.push("");
-	}
-	return lines.join("\n");
-};
-/**
-* One-way codec: structured `TestErrorsResult` → markdown text.
-*
-* `Schema.decodeTo`'s `decode` direction goes
-* `From.Type → To.Encoded`; in this transform `From = TestErrorsResult`
-* and `To = Schema.String`, so the resulting schema is
-* `Schema<string, TestErrorsResultType>` — its parsed Type is the
-* markdown string and its Encoded form is the structured row. That
-* means `Schema.decode(TestErrorsAsMarkdown)(data)` produces markdown
-* (the rendering direction) and `Schema.encode(...)` would attempt
-* the lossy reverse, which is forbidden here.
-*
-* Boundary callers should use
-* `Schema.decodeSync(TestErrorsAsMarkdown)(data)` to render. Test
-* suites can drive the same path without mocking anything — the
-* transform IS the rendering contract.
-*/
-const TestErrorsAsMarkdown = TestErrorsResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform((data) => formatTestErrorsMarkdown(data)),
-	encode: SchemaGetter.forbidden(() => "TestErrorsAsMarkdown is one-way: markdown cannot be parsed back to TestErrorsResult. Consume the procedure's structured output (or MCP structuredContent) directly.")
-}));
 /**
 * The `test_errors` tool's parameters.
 *
@@ -196,11 +117,11 @@ const handleTestErrors = (input) => Effect.gen(function* () {
 * @public
 */
 const testErrorsTool = Tool.make("test_errors", {
-	description: "Use when a test fails and you need error detail, diffs, and the cite-able test_errors.id / stack_frames.id values needed by hypothesis (action: record). Returns both a markdown rendering (in content[].text) and a typed JSON object (in structuredContent) — agents should prefer structuredContent.errors[].",
+	description: "Use when a test fails and you need error detail, diffs, and the cite-able test_errors.id / stack_frames.id values needed by hypothesis (action: record). Returns a typed JSON object in structuredContent; read structuredContent.errors[].",
 	parameters: TestErrorsInput,
 	success: TestErrorsResult,
 	dependencies: [DataReader]
-}).annotate(Tool.Title, "Test errors").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => formatTestErrorsMarkdown(encoded));
+}).annotate(Tool.Title, "Test errors").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
 
 //#endregion
-export { TestErrorAnnotation, TestErrorRow, TestErrorsInput, TestErrorsResult, formatTestErrorsMarkdown, handleTestErrors, testErrorsTool };
+export { TestErrorAnnotation, TestErrorRow, TestErrorsInput, TestErrorsResult, handleTestErrors, testErrorsTool };

package/tools/failure-signature-get.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";
 
@@ -35,28 +34,6 @@ const FailureSignatureGetResult = Schema.Union([SignatureFound, SignatureMissing
 	title: "failure_signature_get result",
 	description: "Discriminate on `found`. Found rows carry first/last-seen timestamps and recent occurrences."
 });
-const formatFailureSignatureMarkdown = (data) => {
-	if (!data.found) return `No failure signature found with hash=${data.requestedHash}.`;
-	const lines = [
-		`# Failure Signature \`${data.signatureHash}\``,
-		"",
-		`**Hash:** ${data.signatureHash}`,
-		"",
-		`- first_seen_at: ${data.firstSeenAt}`,
-		`- last_seen_at: ${data.lastSeenAt ?? "unknown"}`,
-		`- first_seen_run_id: ${data.firstSeenRunId ?? "unknown"}`,
-		`- occurrence_count: ${data.occurrenceCount}`
-	];
-	if (data.recentErrors.length > 0) {
-		lines.push("", "## Recent Errors", "");
-		for (const e of data.recentErrors) lines.push(`- run=${e.runId} name=${e.errorName ?? "(none)"}: ${e.message.slice(0, 120)}`);
-	}
-	return lines.join("\n");
-};
-const FailureSignatureGetAsMarkdown = FailureSignatureGetResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform((data) => formatFailureSignatureMarkdown(data)),
-	encode: SchemaGetter.forbidden(() => "FailureSignatureGetAsMarkdown is one-way.")
-}));
 /**
 * The `failure_signature_get` tool's parameters.
 *
@@ -85,11 +62,11 @@ const handleFailureSignatureGet = (input) => Effect.gen(function* () {
 * @public
 */
 const failureSignatureGetTool = Tool.make("failure_signature_get", {
-	description: "Use when you have a failure-signature hash and need its first-seen date and occurrence history. Returns markdown in content[] and a typed JSON object in structuredContent ({ found, signatureHash?, firstSeenAt?, occurrenceCount?, recentErrors?[] } or absent variant).",
+	description: "Use when you have a failure-signature hash and need its first-seen date and occurrence history. Returns a typed JSON object in structuredContent ({ found, signatureHash?, firstSeenAt?, occurrenceCount?, recentErrors?[] } or absent variant).",
 	parameters: FailureSignatureGetInput,
 	success: FailureSignatureGetResult,
 	dependencies: [DataReader]
-}).annotate(Tool.Title, "Failure signature").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => formatFailureSignatureMarkdown(encoded));
+}).annotate(Tool.Title, "Failure signature").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
 
 //#endregion
-export { FailureSignatureGetInput, FailureSignatureGetResult, failureSignatureGetTool, formatFailureSignatureMarkdown, handleFailureSignatureGet };
+export { FailureSignatureGetInput, FailureSignatureGetResult, failureSignatureGetTool, handleFailureSignatureGet };

package/tools/file-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 { CoverageTotals, FileCoverageReport } from "@vitest-agent/sdk";
@@ -44,37 +43,6 @@ const FileCoverageResult = Schema.Union([
 	title: "file_coverage result",
 	description: "Per-file coverage with related tests. Discriminate on `dataAvailable` then on `matched`."
 });
-const formatFileCoverageMarkdown = (data) => {
-	if (!data.dataAvailable) return "No coverage data available. Run tests with coverage enabled.";
-	const lines = [`# Coverage: \`${data.filePath}\``, ""];
-	const metrics = [
-		"statements",
-		"branches",
-		"functions",
-		"lines"
-	];
-	if (data.matched) {
-		lines.push("## Metrics", "", "| Metric | Value | Threshold |", "| --- | --- | --- |");
-		for (const metric of metrics) {
-			const value = data.report.summary[metric];
-			const threshold = data.globalThresholds[metric];
-			const thresholdStr = threshold !== void 0 ? `${threshold}%` : "—";
-			const icon = threshold !== void 0 && value < threshold ? "❌" : "✅";
-			lines.push(`| ${metric} | ${icon} ${value.toFixed(2)}% | ${thresholdStr} |`);
-		}
-		if (data.report.uncoveredLines) lines.push("", "## Uncovered Lines", "", `\`${data.report.uncoveredLines}\``);
-		lines.push("", "## Next steps", "", "- Use test({ action: \"for_file\" }) to find tests covering this file", "- Write tests targeting the uncovered lines");
-	} else lines.push("This file is not in the low-coverage list.", "", "Possible reasons:", "- File meets all coverage thresholds", "- File was not included in the coverage run", "- File path does not match any tracked source file", "", "## Project Coverage Totals", "", "| Metric | Value |", "| --- | --- |", `| statements | ${data.totals.statements.toFixed(2)}% |`, `| branches | ${data.totals.branches.toFixed(2)}% |`, `| functions | ${data.totals.functions.toFixed(2)}% |`, `| lines | ${data.totals.lines.toFixed(2)}% |`);
-	if (data.relatedTestFiles.length > 0) {
-		lines.push("", "## Tests Covering This File", "");
-		for (const tf of data.relatedTestFiles) lines.push(`- \`${tf}\``);
-	}
-	return lines.join("\n");
-};
-const FileCoverageAsMarkdown = FileCoverageResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform((data) => formatFileCoverageMarkdown(data)),
-	encode: SchemaGetter.forbidden(() => "FileCoverageAsMarkdown is one-way.")
-}));
 /**
 * The `file_coverage` tool's parameters.
 *
@@ -123,11 +91,11 @@ const handleFileCoverage = (input) => Effect.gen(function* () {
 * @public
 */
 const fileCoverageTool = Tool.make("file_coverage", {
-	description: "Use when you need coverage for one source file: per-metric values, uncovered lines, and related tests. Returns markdown in content[] and a typed JSON object in structuredContent ({ dataAvailable, matched?, filePath, report?, totals?, relatedTestFiles[] }).",
+	description: "Use when you need coverage for one source file: per-metric values, uncovered lines, and related tests. Returns a typed JSON object in structuredContent ({ dataAvailable, matched?, filePath, report?, totals?, relatedTestFiles[] }).",
 	parameters: FileCoverageInput,
 	success: FileCoverageResult,
 	dependencies: [DataReader]
-}).annotate(Tool.Title, "File coverage").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => formatFileCoverageMarkdown(encoded));
+}).annotate(Tool.Title, "File coverage").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
 
 //#endregion
-export { FileCoverageInput, FileCoverageResult, fileCoverageTool, formatFileCoverageMarkdown, handleFileCoverage };
+export { FileCoverageInput, FileCoverageResult, fileCoverageTool, handleFileCoverage };

package/tools/help.js

@@ -1,4 +1,3 @@
-import { RenderText } from "../annotations.js";
 import { Effect, Schema } from "effect";
 import { Tool } from "effect/unstable/ai";
 
@@ -11,7 +10,7 @@ import { Tool } from "effect/unstable/ai";
 const HelpResult = Schema.Struct({ helpText: Schema.String.annotate({ description: "Markdown table of every MCP tool with parameters and a one-line description." }) }).annotate({
 	identifier: "HelpResult",
 	title: "help result",
-	description: "Static help reference. Read structuredContent.helpText programmatically; the same string lives in content[].text for transcripts."
+	description: "Static help reference. Read structuredContent.helpText."
 });
 /**
 * The static markdown `help` returns. Exported so `__test__/help-drift.test.ts`
@@ -43,7 +42,7 @@ const HELP_TEXT = `# vitest-agent MCP Tools
 | \`file_coverage\` | \`filePath\`, \`project?\` | Per-file coverage with uncovered lines and related tests |
 | \`test_history\` | \`project\` | Flaky/persistent/recovered tests |
 | \`test_trends\` | \`project\`, \`limit?\` | Coverage trajectory over time |
-| \`test_errors\` | \`project\`, \`errorName?\`, \`format?\` (\`markdown\` \\| \`xml\`) | Errors with diffs, stacks, each row's \`annotations[]\` (the test annotations the author recorded), and the cite-able \`testErrorId\` / \`topStackFrameId\` values needed by \`hypothesis (action: record)\` |
+| \`test_errors\` | \`project\`, \`errorName?\` | Errors with diffs, stacks, each row's \`annotations[]\` (the test annotations the author recorded), and the cite-able \`testErrorId\` / \`topStackFrameId\` values needed by \`hypothesis (action: record)\` |
 | \`test\` | \`action\` (\`list\`/\`get\`/\`for_file\`/\`for_tag\`/\`annotations\`/\`artifacts\`), plus per-action params | Consolidated test inspection: list/get/for_file/for_tag/annotations/artifacts |
 
 \`test\` actions:
@@ -169,16 +168,15 @@ Six framing-only prompts (\`prompts/get\`; Claude Code surfaces them as slash co
 - \`scope\` accepts: \`global\`, \`project\`, \`module\`, \`suite\`, \`test\`, \`note\`
 `;
 /**
-* The Effect-native `help` tool. Renders the help markdown as the text
-* channel via `RenderText` while `structuredContent.helpText` carries the
-* same string for programmatic readers.
+* The Effect-native `help` tool. `structuredContent.helpText` carries the
+* markdown reference.
 *
 * @public
 */
 const helpTool = Tool.make("help", {
-	description: "List all available MCP tools with parameters. Read structuredContent.helpText programmatically; the same markdown lives in content[].text.",
+	description: "List all available MCP tools with parameters. The markdown reference is in structuredContent.helpText.",
 	success: HelpResult
-}).annotate(Tool.Title, "Help").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => encoded.helpText);
+}).annotate(Tool.Title, "Help").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
 /**
 * Handler for {@link helpTool}.
 *

package/tools/history.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";
 import { HistoryRecord } from "@vitest-agent/sdk";
@@ -54,41 +53,6 @@ const TestHistoryResult = Schema.Struct({
 	title: "test_history result",
 	description: "Per-project flaky/persistent/recovered test classifications computed from `test_runs` history."
 });
-const formatTestHistoryMarkdown = (data) => {
-	if (!data.hasData) return `No history data available for project \`${data.project}\`. Run tests first.`;
-	const lines = [`# Test History: ${data.project}`, ""];
-	if (data.flaky.length > 0) {
-		lines.push("## Flaky Tests", "", "Tests with mixed pass/fail results across recent runs:", "");
-		for (const test of data.flaky) {
-			const total = test.passCount + test.failCount;
-			const passRate = total > 0 ? (test.passCount / total * 100).toFixed(0) : "0";
-			lines.push(`### ⚠️ ${test.fullName}`, "", `- Module: \`${test.modulePath}\``, `- Pass rate: ${passRate}% (${test.passCount}/${total})`, `- Last state: ${test.lastState}`, `- Last run: ${new Date(test.lastTimestamp).toLocaleString()}`, "");
-		}
-	}
-	if (data.persistent.length > 0) {
-		lines.push("## Persistent Failures", "", "Tests that have failed in consecutive runs:", "");
-		for (const failure of data.persistent) {
-			lines.push(`### ❌ ${failure.fullName}`, "", `- Module: \`${failure.modulePath}\``, `- Consecutive failures: ${failure.consecutiveFailures}`, `- First failed: ${new Date(failure.firstFailedAt).toLocaleString()}`, `- Last failed: ${new Date(failure.lastFailedAt).toLocaleString()}`);
-			if (failure.lastErrorMessage !== null) lines.push(`- Last error: ${failure.lastErrorMessage}`);
-			lines.push("");
-		}
-	}
-	if (data.recovered.length > 0) {
-		lines.push("## Recovered Tests", "", "Tests that previously failed but are now passing:", "");
-		for (const test of data.recovered) {
-			const runViz = test.recentRuns.map((s) => s === "passed" ? "P" : "F").join("");
-			lines.push(`- ✅ **${test.fullName}** (${test.modulePath}) — recent runs: \`${runViz}\``);
-		}
-		lines.push("");
-	}
-	if (data.flaky.length === 0 && data.persistent.length === 0 && data.recovered.length === 0) lines.push("✅ No flaky, persistent, or recently recovered tests.", "");
-	lines.push(`_History updated: ${data.history.updatedAt}_`);
-	return lines.join("\n");
-};
-const TestHistoryAsMarkdown = TestHistoryResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform((data) => formatTestHistoryMarkdown(data)),
-	encode: SchemaGetter.forbidden(() => "TestHistoryAsMarkdown is one-way: markdown cannot be parsed back to TestHistoryResult.")
-}));
 /**
 * The `test_history` tool's parameters.
 *
@@ -147,11 +111,11 @@ const handleTestHistory = (input) => Effect.gen(function* () {
 * @public
 */
 const testHistoryTool = Tool.make("test_history", {
-	description: "Use when failures recur and you need flaky, persistent, and recovered test classifications. Returns markdown in content[] and a typed JSON object in structuredContent (project, hasData, history, flaky[], persistent[], recovered[]). Optional testName/modulePath narrow to a single test; limit caps runs kept per test (default 20) — omit all three only when you actually need the whole project's history.",
+	description: "Use when failures recur and you need flaky, persistent, and recovered test classifications. Returns a typed JSON object in structuredContent (project, hasData, history, flaky[], persistent[], recovered[]). Optional testName/modulePath narrow to a single test; limit caps runs kept per test (default 20) — omit all three only when you actually need the whole project's history.",
 	parameters: TestHistoryInput,
 	success: TestHistoryResult,
 	dependencies: [DataReader]
-}).annotate(Tool.Title, "Test history").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => formatTestHistoryMarkdown(encoded));
+}).annotate(Tool.Title, "Test history").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
 
 //#endregion
-export { TestHistoryInput, TestHistoryResult, formatTestHistoryMarkdown, handleTestHistory, testHistoryTool };
+export { TestHistoryInput, TestHistoryResult, handleTestHistory, testHistoryTool };

package/tools/hypothesis.js

@@ -1,4 +1,3 @@
-import { RenderText } from "../annotations.js";
 import { McpSession } from "../session.js";
 import { IdempotentReplayMarker } from "../utils/replay-marker.js";
 import { Effect, Match, Option, Schema } from "effect";
@@ -42,20 +41,8 @@ const HypothesisResult = Schema.Union([
 	title: "hypothesis result",
 	description: "Discriminate on `action`. record returns the new id; list returns the matching rows; validate returns an empty acknowledgement."
 });
-const formatHypothesisListMarkdown = (data) => {
-	if (data.action !== "list") return JSON.stringify(data, null, 2);
-	if (data.hypotheses.length === 0) return "No hypotheses matched.";
-	const lines = ["# Hypotheses", ""];
-	for (const h of data.hypotheses) {
-		const status = h.validationOutcome ?? "open";
-		lines.push(`- [${status}] id=${h.id} session=${h.sessionId}: ${h.content.slice(0, 120)}`);
-	}
-	return lines.join("\n");
-};
 /** Number-or-numeric-string id: LLM orchestrators routinely stringify numeric tool inputs. */
 const CoercibleId = Schema.Union([Schema.Finite, Schema.FiniteFromString]);
-/** The text channel: `list` renders markdown; `record` / `validate` render the pretty-printed JSON. */
-const renderHypothesisText = (data) => data.action === "list" ? formatHypothesisListMarkdown(data) : JSON.stringify(data, null, 2);
 const RecordVariant = Schema.Struct({
 	action: Schema.Literal("record").annotate({ description: "CRUD discriminator" }),
 	tddTaskId: Schema.optionalKey(CoercibleId).annotate({ description: "record: tdd task id returned by tdd_task action='start' — binds the hypothesis to that task's session deterministically" }),
@@ -173,7 +160,7 @@ const handleHypothesis = (input) => Match.value(input).pipe(Match.discriminators
 * @public
 */
 const hypothesisTool = Tool.make("hypothesis", {
-	description: "Use to manage debugging hypotheses, with a CRUD action discriminator: action='record' (content, tddTaskId?, optional citation ids) writes a hypothesis — the binding session is resolved server-side from the recovered host context (active TDD subagent, else main session); pass tddTaskId (returned by tdd_task action='start') to bind deterministically to that task's session, and do not pass sessionId when recording; action='validate' (id, outcome, validatedAt?) records a validation outcome — validatedAt is optional and defaults server-side to now when omitted, or is honored verbatim when supplied; action='list' (sessionId?, outcome?, limit?) returns matching hypotheses as markdown.",
+	description: "Use to manage debugging hypotheses, with a CRUD action discriminator: action='record' (content, tddTaskId?, optional citation ids) writes a hypothesis — the binding session is resolved server-side from the recovered host context (active TDD subagent, else main session); pass tddTaskId (returned by tdd_task action='start') to bind deterministically to that task's session, and do not pass sessionId when recording; action='validate' (id, outcome, validatedAt?) records a validation outcome — validatedAt is optional and defaults server-side to now when omitted, or is honored verbatim when supplied; action='list' (sessionId?, outcome?, limit?) returns matching hypotheses.",
 	parameters: HypothesisInput,
 	success: HypothesisResult,
 	dependencies: [
@@ -181,7 +168,7 @@ const hypothesisTool = Tool.make("hypothesis", {
 		DataStore,
 		McpSession
 	]
-}).annotate(Tool.Title, "Hypothesis").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, false).annotate(RenderText, (encoded) => renderHypothesisText(encoded));
+}).annotate(Tool.Title, "Hypothesis").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, false);
 
 //#endregion
-export { HypothesisInput, HypothesisResult, formatHypothesisListMarkdown, handleHypothesis, hypothesisTool };
+export { HypothesisInput, HypothesisResult, handleHypothesis, hypothesisTool };

package/tools/inventory.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";
 
@@ -129,98 +128,6 @@ const InventoryResult = Schema.Union([
 	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 = InventoryResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform((data) => formatInventoryMarkdown(data)),
-	encode: SchemaGetter.forbidden(() => "InventoryAsMarkdown is one-way.")
-}));
 const ProjectVariant = Schema.Struct({ kind: Schema.Literal("project") });
 const ModuleVariant = Schema.Struct({
 	kind: Schema.Literal("module"),
@@ -389,7 +296,7 @@ const inventoryTool = Tool.make("inventory", {
 	parameters: InventoryInput,
 	success: InventoryResult,
 	dependencies: [DataReader]
-}).annotate(Tool.Title, "Inventory").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => formatInventoryMarkdown(encoded));
+}).annotate(Tool.Title, "Inventory").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
 
 //#endregion
-export { InventoryInput, InventoryResult, formatInventoryMarkdown, handleInventory, inventoryTool };
+export { InventoryInput, InventoryResult, handleInventory, inventoryTool };

package/tools/note.js

@@ -1,4 +1,3 @@
-import { RenderText } from "../annotations.js";
 import { Effect, Match, Option, Schema } from "effect";
 import { DataReader, DataStore } from "@vitest-agent/engine";
 import { Tool } from "effect/unstable/ai";
@@ -78,45 +77,6 @@ const NoteResult = Schema.Union([
 	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);
-};
-/**
-* The text channel: list/search render markdown; the mutation actions
-* (create/get/update/delete) render the pretty-printed JSON, exactly as
-* the old `structuredJsonResult` boundary did.
-*/
-const renderNoteText = (data) => data.action === "list" || data.action === "search" ? formatNoteListMarkdown(data) : JSON.stringify(data, null, 2);
 const CreateVariant = Schema.Struct({
 	action: Schema.Literal("create").annotate({ description: "CRUD discriminator" }),
 	title: Schema.String,
@@ -251,11 +211,11 @@ const handleNote = (input) => Match.value(input).pipe(Match.discriminatorsExhaus
 * @public
 */
 const noteTool = Tool.make("note", {
-	description: "Use to manage notes, with a CRUD action discriminator: action='create' writes a scoped note; action='list' (scope?, project?, testFullName?) returns matching notes; action='get' (id) returns a structured note; action='update' (id, ...patch) edits; action='delete' (id) removes; action='search' (query) does FTS5 across title and content. structuredContent always carries the typed result (discriminate on `action`); list/search additionally render markdown in the text channel.",
+	description: "Use to manage notes, with a CRUD action discriminator: action='create' writes a scoped note; action='list' (scope?, project?, testFullName?) returns matching notes; action='get' (id) returns a structured note; action='update' (id, ...patch) edits; action='delete' (id) removes; action='search' (query) does FTS5 across title and content. structuredContent always carries the typed result (discriminate on `action`).",
 	parameters: NoteParams,
 	success: NoteResult,
 	dependencies: [DataReader, DataStore]
-}).annotate(Tool.Title, "Note").annotate(Tool.Readonly, false).annotate(Tool.Destructive, true).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, false).annotate(RenderText, (encoded) => renderNoteText(encoded));
+}).annotate(Tool.Title, "Note").annotate(Tool.Readonly, false).annotate(Tool.Destructive, true).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, false);
 
 //#endregion
-export { NoteParams, NoteResult, formatNoteListMarkdown, handleNote, noteTool };
+export { NoteParams, NoteResult, handleNote, noteTool };

package/tools/overview.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";
 
@@ -40,37 +39,6 @@ const TestOverviewResult = Schema.Union([OverviewAvailable, OverviewAbsent]).ann
 	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 = TestOverviewResult.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform((data) => formatTestOverviewMarkdown(data)),
-	encode: SchemaGetter.forbidden(() => "TestOverviewAsMarkdown is one-way.")
-}));
 /**
 * The `test_overview` tool's parameters.
 *
@@ -108,11 +76,11 @@ const handleTestOverview = (input) => Effect.gen(function* () {
 * @public
 */
 const testOverviewTool = Tool.make("test_overview", {
-	description: "Use when you want a summary of the test landscape with per-project run metrics. Returns markdown in content[] and a typed JSON object in structuredContent ({ dataAvailable, projectFilter?, runs[] } or absent variant).",
+	description: "Use when you want a summary of the test landscape with per-project run metrics. Returns a typed JSON object in structuredContent ({ dataAvailable, projectFilter?, runs[] } or absent variant).",
 	parameters: TestOverviewInput,
 	success: TestOverviewResult,
 	dependencies: [DataReader]
-}).annotate(Tool.Title, "Test overview").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => formatTestOverviewMarkdown(encoded));
+}).annotate(Tool.Title, "Test overview").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
 
 //#endregion
-export { TestOverviewInput, TestOverviewResult, formatTestOverviewMarkdown, handleTestOverview, testOverviewTool };
+export { TestOverviewInput, TestOverviewResult, handleTestOverview, testOverviewTool };