@vitest-agent/mcp 1.3.6 → 2.0.0

package/index.js

@@ -11,7 +11,7 @@ import { startMcpServer } from "./server.js";
 *
 * @public
 */
-const CURRENT_MCP_VERSION = "1.3.6";
+const CURRENT_MCP_VERSION = "2.0.0";
 
 //#endregion
 export { CURRENT_MCP_VERSION, McpLive, appRouter, createCallerFactory, createCurrentSessionIdRef, createSessionContextRef, startMcpServer };

package/layers/McpLive.js

@@ -1,5 +1,4 @@
-import { NodeFileSystem } from "@effect/platform-node";
-import * as NodeContext$1 from "@effect/platform-node/NodeContext";
+import * as NodeServices from "@effect/platform-node/NodeServices";
 import { layer } from "@effect/sql-sqlite-node/SqliteClient";
 import * as SqliteMigrator from "@effect/sql-sqlite-node/SqliteMigrator";
 import { DataReaderLive, DataStoreLive, LoggerLive, OutputPipelineLive, ProjectDiscoveryLive, migration0001 } from "@vitest-agent/sdk";
@@ -10,7 +9,7 @@ import { Layer } from "effect";
 * Builds the Effect Layer that provides all services required by the MCP server.
 *
 * Composes DataReader, DataStore, ProjectDiscovery, OutputPipeline, SQLite
-* client, migrator, NodeContext, NodeFileSystem, and the logger into a single
+* client, migrator, NodeServices, and the logger into a single
 * layer suitable for `ManagedRuntime.make`.
 *
 * @param dbPath - absolute path to the SQLite database file
@@ -21,9 +20,9 @@ import { Layer } from "effect";
 */
 const McpLive = (dbPath, logLevel, logFile) => {
 	const SqliteLayer = layer({ filename: dbPath });
-	const PlatformLayer = NodeContext$1.layer;
+	const PlatformLayer = NodeServices.layer;
 	const MigratorLayer = SqliteMigrator.layer({ loader: SqliteMigrator.fromRecord({ "0001_initial": migration0001 }) }).pipe(Layer.provide(Layer.merge(SqliteLayer, PlatformLayer)));
-	return Layer.mergeAll(DataReaderLive, DataStoreLive, ProjectDiscoveryLive, OutputPipelineLive).pipe(Layer.provideMerge(MigratorLayer), Layer.provideMerge(SqliteLayer), Layer.provideMerge(PlatformLayer), Layer.provideMerge(NodeFileSystem.layer), Layer.provideMerge(LoggerLive(logLevel, logFile)));
+	return Layer.mergeAll(DataReaderLive, DataStoreLive, ProjectDiscoveryLive, OutputPipelineLive).pipe(Layer.provideMerge(MigratorLayer), Layer.provideMerge(SqliteLayer), Layer.provideMerge(PlatformLayer), Layer.provideMerge(LoggerLive(logLevel, logFile)));
 };
 
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/mcp",
-	"version": "1.3.6",
+	"version": "2.0.0",
 	"private": false,
 	"description": "Model Context Protocol server for vitest-agent. Exposes 53 tools for agent access to test data, TDD lifecycle, and session management.",
 	"keywords": [
@@ -29,7 +29,8 @@
 	"exports": {
 		".": {
 			"types": "./index.d.ts",
-			"import": "./index.js"
+			"import": "./index.js",
+			"default": "./index.js"
 		},
 		"./package.json": "./package.json"
 	},
@@ -37,18 +38,12 @@
 		"vitest-agent-mcp": "bin/vitest-agent-mcp.js"
 	},
 	"dependencies": {
-		"@effect/cluster": "^0.59.0",
-		"@effect/experimental": "^0.60.0",
-		"@effect/platform": "^0.96.2",
-		"@effect/platform-node": "^0.107.0",
-		"@effect/rpc": "^0.75.1",
-		"@effect/sql": "^0.51.1",
-		"@effect/sql-sqlite-node": "^0.52.0",
-		"@effect/workflow": "^0.18.2",
+		"@effect/platform-node": "4.0.0-beta.98",
+		"@effect/sql-sqlite-node": "4.0.0-beta.98",
 		"@modelcontextprotocol/sdk": "^1.29.0",
 		"@trpc/server": "^11.18.0",
-		"@vitest-agent/sdk": "1.3.4",
-		"effect": "^3.21.4",
+		"@vitest-agent/sdk": "2.0.0",
+		"effect": "4.0.0-beta.98",
 		"zod": "^4.4.3"
 	},
 	"peerDependencies": {

package/server.js

@@ -32,7 +32,7 @@ import { appRouter } from "./router.js";
 import { registerAllPrompts } from "./prompts/index.js";
 import { effectToZodSchema } from "./utils/effect-to-zod.js";
 import { ChannelEvent, DataReader } from "@vitest-agent/sdk";
-import { Effect, Option, Schema } from "effect";
+import { Effect, Exit, Option, Schema } from "effect";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
@@ -45,9 +45,9 @@ import { z } from "zod";
 * Returns the enriched event object or the original on resolution failure.
 */
 async function resolveChannelEvent(ctx, raw) {
-	const decoded = Schema.decodeUnknownEither(ChannelEvent)(raw);
-	if (decoded._tag === "Left") return raw;
-	const event = decoded.right;
+	const decoded = Schema.decodeUnknownExit(ChannelEvent)(raw);
+	if (Exit.isFailure(decoded)) return raw;
+	const event = decoded.value;
 	return ctx.runtime.runPromise(Effect.gen(function* () {
 		const reader = yield* DataReader;
 		switch (event.type) {
@@ -114,7 +114,7 @@ function structuredResult(text, structured) {
 * tools that previously rendered their result as JSON.stringify; the
 * structured payload is identical, so the agent gets the typed object
 * via MCP's structuredContent channel without paying the markdown
-* formatter ceremony of `Schema.transformOrFail`.
+* formatter ceremony of `Schema.decodeTo`.
 *
 * @internal
 */

package/tools/_tdd-error-envelope.js

@@ -92,7 +92,7 @@ const tddErrorToEnvelope = (e) => {
 	if (e instanceof TddTaskAlreadyEndedError) return tddTaskAlreadyEnded(e);
 	return illegalStatusTransition(e);
 };
-const catchTddErrorsAsEnvelope = (effect) => effect.pipe(Effect.catchAll((e) => isKnownTddError(e) ? Effect.succeed(tddErrorToEnvelope(e)) : Effect.fail(e)));
+const catchTddErrorsAsEnvelope = (effect) => effect.pipe(Effect.catch((e) => isKnownTddError(e) ? Effect.succeed(tddErrorToEnvelope(e)) : Effect.fail(e)));
 
 //#endregion
 export { catchTddErrorsAsEnvelope };

package/tools/acceptance-metrics.js

@@ -1,6 +1,6 @@
 import { publicProcedure } from "../context.js";
 import { DataReader } from "@vitest-agent/sdk";
-import { Effect, ParseResult, Schema } from "effect";
+import { Effect, Schema, SchemaGetter } from "effect";
 
 //#region src/tools/acceptance-metrics.ts
 /**
@@ -17,38 +17,38 @@ const totalAnnotation = { description: "Sample size — number of observations t
 const ratioAnnotation = { description: "Compliance ratio in [0, 1]. Multiply by 100 for the percentage form rendered in the markdown view." };
 const AcceptanceMetricsResult = Schema.Struct({
 	phaseEvidenceIntegrity: Schema.Struct({
-		total: Schema.Number.annotations(totalAnnotation),
-		compliant: Schema.Number.annotations({ description: "Phase transitions that cited a valid artifact and passed binding-rule validation." }),
-		ratio: Schema.Number.annotations(ratioAnnotation)
-	}).annotations({
+		total: Schema.Number.annotate(totalAnnotation),
+		compliant: Schema.Number.annotate({ description: "Phase transitions that cited a valid artifact and passed binding-rule validation." }),
+		ratio: Schema.Number.annotate(ratioAnnotation)
+	}).annotate({
 		title: "Phase-evidence integrity",
 		description: "Fraction of accepted TDD phase transitions whose cited artifact satisfied the D2 binding rules. Spec target ≥80%."
 	}),
 	complianceHookResponsiveness: Schema.Struct({
-		total: Schema.Number.annotations(totalAnnotation),
-		withFollowup: Schema.Number.annotations({ description: "PreToolUse denials / `additionalContext` reminders the orchestrator acknowledged in the next turn." }),
-		ratio: Schema.Number.annotations(ratioAnnotation)
-	}).annotations({
+		total: Schema.Number.annotate(totalAnnotation),
+		withFollowup: Schema.Number.annotate({ description: "PreToolUse denials / `additionalContext` reminders the orchestrator acknowledged in the next turn." }),
+		ratio: Schema.Number.annotate(ratioAnnotation)
+	}).annotate({
 		title: "Compliance-hook responsiveness",
 		description: "Fraction of compliance signals from PreToolUse hooks the orchestrator acted on. Spec target ≥40%."
 	}),
 	orientationUsefulness: Schema.Struct({
-		total: Schema.Number.annotations(totalAnnotation),
-		referencedCount: Schema.Number.annotations({ description: "Sessions where `triage_brief` / `wrapup_prompt` content was referenced in subsequent decisions." }),
-		ratio: Schema.Number.annotations(ratioAnnotation)
-	}).annotations({
+		total: Schema.Number.annotate(totalAnnotation),
+		referencedCount: Schema.Number.annotate({ description: "Sessions where `triage_brief` / `wrapup_prompt` content was referenced in subsequent decisions." }),
+		ratio: Schema.Number.annotate(ratioAnnotation)
+	}).annotate({
 		title: "Orientation usefulness",
 		description: "Fraction of sessions where orientation prompts measurably steered orchestrator behaviour. Spec target ≥50%."
 	}),
 	antiPatternDetectionRate: Schema.Struct({
-		total: Schema.Number.annotations(totalAnnotation),
-		cleanSessions: Schema.Number.annotations({ description: "Sessions that produced no `tdd_artifacts(kind='test_weakened')` rows or DATABASE_BYPASS notes." }),
-		ratio: Schema.Number.annotations(ratioAnnotation)
-	}).annotations({
+		total: Schema.Number.annotate(totalAnnotation),
+		cleanSessions: Schema.Number.annotate({ description: "Sessions that produced no `tdd_artifacts(kind='test_weakened')` rows or DATABASE_BYPASS notes." }),
+		ratio: Schema.Number.annotate(ratioAnnotation)
+	}).annotate({
 		title: "Anti-pattern detection rate",
 		description: "Fraction of sessions free of weakening edits or sqlite3 bypass attempts. Spec target ≥95%."
 	})
-}).annotations({
+}).annotate({
 	identifier: "AcceptanceMetricsResult",
 	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."
@@ -62,12 +62,11 @@ const formatAcceptanceMetricsMarkdown = (m) => [
 	`3. Orientation usefulness: ${fmtBucket(m.orientationUsefulness)} — target ≥50%`,
 	`4. Anti-pattern detection rate: ${fmtBucket(m.antiPatternDetectionRate)} — target ≥95%`
 ].join("\n");
-const AcceptanceMetricsAsMarkdown = Schema.transformOrFail(AcceptanceMetricsResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(formatAcceptanceMetricsMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "AcceptanceMetricsAsMarkdown is one-way: markdown cannot be parsed back to AcceptanceMetricsResult."))
-});
-const acceptanceMetrics = publicProcedure.input(Schema.standardSchemaV1(Schema.Struct({}))).query(async ({ ctx }) => ctx.runtime.runPromise(Effect.gen(function* () {
+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.")
+}));
+const acceptanceMetrics = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({}))).query(async ({ ctx }) => ctx.runtime.runPromise(Effect.gen(function* () {
 	return yield* (yield* DataReader).computeAcceptanceMetrics();
 })));
 

package/tools/cache-health.js

@@ -1,6 +1,6 @@
 import { publicProcedure } from "../context.js";
 import { CacheManifest, DataReader } from "@vitest-agent/sdk";
-import { Effect, Option, ParseResult, Schema } from "effect";
+import { Effect, Option, Schema, SchemaGetter } from "effect";
 
 //#region src/tools/cache-health.ts
 /**
@@ -16,19 +16,19 @@ import { Effect, Option, ParseResult, Schema } from "effect";
 * @packageDocumentation
 */
 const ManifestPresent = Schema.Struct({
-	manifestPresent: Schema.Literal(true).annotations({ description: "Discriminant — `true` when a cache manifest exists." }),
-	manifest: CacheManifest.annotations({ description: "Full cache manifest content as written by the reporter." }),
-	ageMs: Schema.Number.annotations({ description: "Milliseconds since the manifest was last updated. Computed at query time, not stored." }),
-	stale: Schema.Boolean.annotations({ description: "Convenience flag — `true` when `ageMs` exceeds 24 hours, otherwise `false`." })
-}).annotations({
+	manifestPresent: Schema.Literal(true).annotate({ description: "Discriminant — `true` when a cache manifest exists." }),
+	manifest: CacheManifest.annotate({ description: "Full cache manifest content as written by the reporter." }),
+	ageMs: Schema.Number.annotate({ description: "Milliseconds since the manifest was last updated. Computed at query time, not stored." }),
+	stale: Schema.Boolean.annotate({ description: "Convenience flag — `true` when `ageMs` exceeds 24 hours, otherwise `false`." })
+}).annotate({
 	identifier: "CacheHealthPresent",
 	title: "Cache manifest present"
 });
-const ManifestAbsent = Schema.Struct({ manifestPresent: Schema.Literal(false).annotations({ description: "Discriminant — `false` when no manifest has been written yet (run tests to populate the cache)." }) }).annotations({
+const ManifestAbsent = Schema.Struct({ manifestPresent: Schema.Literal(false).annotate({ description: "Discriminant — `false` when no manifest has been written yet (run tests to populate the cache)." }) }).annotate({
 	identifier: "CacheHealthAbsent",
 	title: "Cache manifest absent"
 });
-const CacheHealthResult = Schema.Union(ManifestPresent, ManifestAbsent).annotations({
+const CacheHealthResult = Schema.Union([ManifestPresent, ManifestAbsent]).annotate({
 	identifier: "CacheHealthResult",
 	title: "cache_health result",
 	description: "Cache health snapshot. Discriminate on `manifestPresent` to see whether the manifest exists."
@@ -61,11 +61,10 @@ const formatCacheHealthMarkdown = (data) => {
 	}
 	return lines.join("\n");
 };
-const CacheHealthAsMarkdown = Schema.transformOrFail(CacheHealthResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(formatCacheHealthMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "CacheHealthAsMarkdown is one-way: markdown cannot be parsed back to CacheHealthResult."))
-});
+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.")
+}));
 const cacheHealth = publicProcedure.query(async ({ ctx }) => ctx.runtime.runPromise(Effect.gen(function* () {
 	const manifestOpt = yield* (yield* DataReader).getManifest();
 	if (Option.isNone(manifestOpt)) return { manifestPresent: false };

package/tools/commit-changes.js

@@ -1,6 +1,6 @@
 import { publicProcedure } from "../context.js";
 import { DataReader } from "@vitest-agent/sdk";
-import { Effect, ParseResult, Schema } from "effect";
+import { Effect, Schema, SchemaGetter } from "effect";
 
 //#region src/tools/commit-changes.ts
 /**
@@ -9,23 +9,29 @@ import { Effect, ParseResult, Schema } from "effect";
 * @packageDocumentation
 */
 const FileRow = Schema.Struct({
-	filePath: Schema.String.annotations({ description: "Repo-relative path of the changed file." }),
-	changeKind: Schema.Literal("added", "modified", "deleted", "renamed", "untracked-modified").annotations({ description: "How the file changed in this commit (or `untracked-modified` for working-tree changes attributed to a commit)." })
-}).annotations({ identifier: "CommitFileRow" });
+	filePath: Schema.String.annotate({ description: "Repo-relative path of the changed file." }),
+	changeKind: Schema.Literals([
+		"added",
+		"modified",
+		"deleted",
+		"renamed",
+		"untracked-modified"
+	]).annotate({ description: "How the file changed in this commit (or `untracked-modified` for working-tree changes attributed to a commit)." })
+}).annotate({ identifier: "CommitFileRow" });
 const CommitRow = Schema.Struct({
-	sha: Schema.String.annotations({ description: "Full git commit SHA-1." }),
-	parentSha: Schema.NullOr(Schema.String).annotations({ description: "Parent commit SHA, or `null` for the root commit / when no parent was recorded." }),
-	message: Schema.NullOr(Schema.String).annotations({ description: "Commit message subject + body, or `null` if not captured." }),
-	author: Schema.NullOr(Schema.String).annotations({ description: "Commit author in `Name <email>` form when captured." }),
-	committedAt: Schema.NullOr(Schema.String).annotations({ description: "ISO-8601 commit timestamp." }),
-	branch: Schema.NullOr(Schema.String).annotations({ description: "Branch the commit was recorded on at hook fire time." }),
-	files: Schema.Array(FileRow).annotations({ description: "Files this commit changed, with per-file change kinds." })
-}).annotations({ identifier: "CommitRow" });
+	sha: Schema.String.annotate({ description: "Full git commit SHA-1." }),
+	parentSha: Schema.NullOr(Schema.String).annotate({ description: "Parent commit SHA, or `null` for the root commit / when no parent was recorded." }),
+	message: Schema.NullOr(Schema.String).annotate({ description: "Commit message subject + body, or `null` if not captured." }),
+	author: Schema.NullOr(Schema.String).annotate({ description: "Commit author in `Name <email>` form when captured." }),
+	committedAt: Schema.NullOr(Schema.String).annotate({ description: "ISO-8601 commit timestamp." }),
+	branch: Schema.NullOr(Schema.String).annotate({ description: "Branch the commit was recorded on at hook fire time." }),
+	files: Schema.Array(FileRow).annotate({ description: "Files this commit changed, with per-file change kinds." })
+}).annotate({ identifier: "CommitRow" });
 const CommitChangesResult = Schema.Struct({
-	filterSha: Schema.optional(Schema.String).annotations({ description: "Echo of the optional `sha` filter the caller passed; absent when no filter was applied (recent commits returned)." }),
-	count: Schema.Number.annotations({ description: "Number of commit rows returned." }),
-	commits: Schema.Array(CommitRow).annotations({ description: "Matching commits, newest first when `sha` was omitted; up to 20 rows." })
-}).annotations({
+	filterSha: Schema.optional(Schema.String).annotate({ description: "Echo of the optional `sha` filter the caller passed; absent when no filter was applied (recent commits returned)." }),
+	count: Schema.Number.annotate({ description: "Number of commit rows returned." }),
+	commits: Schema.Array(CommitRow).annotate({ description: "Matching commits, newest first when `sha` was omitted; up to 20 rows." })
+}).annotate({
 	identifier: "CommitChangesResult",
 	title: "commit_changes result",
 	description: "Commit metadata + per-file changes captured by the post-commit Bash hook."
@@ -46,12 +52,11 @@ const formatCommitChangesMarkdown = (data) => {
 	}
 	return lines.join("\n").trim();
 };
-const CommitChangesAsMarkdown = Schema.transformOrFail(CommitChangesResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(formatCommitChangesMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "CommitChangesAsMarkdown is one-way: markdown cannot be parsed back to CommitChangesResult."))
-});
-const commitChanges = publicProcedure.input(Schema.standardSchemaV1(Schema.Struct({ sha: Schema.optional(Schema.String) }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
+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.")
+}));
+const commitChanges = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({ sha: Schema.optional(Schema.String) }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
 	const entries = yield* (yield* DataReader).getCommitChanges(input.sha);
 	return {
 		...input.sha !== void 0 && { filterSha: input.sha },

package/tools/configure.js

@@ -1,6 +1,6 @@
 import { publicProcedure } from "../context.js";
 import { DataReader } from "@vitest-agent/sdk";
-import { Effect, Option, ParseResult, Schema } from "effect";
+import { Effect, Option, Schema, SchemaGetter } from "effect";
 
 //#region src/tools/configure.ts
 /**
@@ -9,36 +9,33 @@ import { Effect, Option, ParseResult, Schema } from "effect";
 * @packageDocumentation
 */
 const SettingsRowSchema = Schema.Struct({
-	hash: Schema.String.annotations({ description: "Stable SHA-1 of the captured Vitest settings; `test_runs.settings_hash` foreign key." }),
-	reporters: Schema.NullOr(Schema.String).annotations({ description: "Comma-separated reporter list as resolved from the user's vitest config." }),
-	coverageEnabled: Schema.Boolean.annotations({ description: "Whether coverage was on for this run." }),
-	coverageProvider: Schema.NullOr(Schema.String).annotations({ description: "Coverage provider (`v8` or `istanbul`)." }),
-	coverageThresholds: Schema.NullOr(Schema.String).annotations({ description: "JSON-encoded threshold table when present; `null` when no thresholds were configured." }),
-	coverageTargets: Schema.NullOr(Schema.String).annotations({ description: "JSON-encoded aspirational target table when present." }),
-	pool: Schema.NullOr(Schema.String).annotations({ description: "Vitest pool (`forks` / `threads` / `vmThreads`)." }),
-	shard: Schema.NullOr(Schema.String).annotations({ description: "Shard descriptor when running sharded (`1/4` form)." }),
-	project: Schema.NullOr(Schema.String).annotations({ description: "Project name within a multi-project setup." }),
-	environment: Schema.NullOr(Schema.String).annotations({ description: "Test environment (`node`, `jsdom`, etc.)." }),
-	envVars: Schema.Record({
-		key: Schema.String,
-		value: Schema.String
-	}).annotations({ description: "Captured CI / test env vars associated with this settings hash." }),
-	capturedAt: Schema.String.annotations({ description: "ISO-8601 timestamp the settings row was first written." })
-}).annotations({
+	hash: Schema.String.annotate({ description: "Stable SHA-1 of the captured Vitest settings; `test_runs.settings_hash` foreign key." }),
+	reporters: Schema.NullOr(Schema.String).annotate({ description: "Comma-separated reporter list as resolved from the user's vitest config." }),
+	coverageEnabled: Schema.Boolean.annotate({ description: "Whether coverage was on for this run." }),
+	coverageProvider: Schema.NullOr(Schema.String).annotate({ description: "Coverage provider (`v8` or `istanbul`)." }),
+	coverageThresholds: Schema.NullOr(Schema.String).annotate({ description: "JSON-encoded threshold table when present; `null` when no thresholds were configured." }),
+	coverageTargets: Schema.NullOr(Schema.String).annotate({ description: "JSON-encoded aspirational target table when present." }),
+	pool: Schema.NullOr(Schema.String).annotate({ description: "Vitest pool (`forks` / `threads` / `vmThreads`)." }),
+	shard: Schema.NullOr(Schema.String).annotate({ description: "Shard descriptor when running sharded (`1/4` form)." }),
+	project: Schema.NullOr(Schema.String).annotate({ description: "Project name within a multi-project setup." }),
+	environment: Schema.NullOr(Schema.String).annotate({ description: "Test environment (`node`, `jsdom`, etc.)." }),
+	envVars: Schema.Record(Schema.String, Schema.String).annotate({ description: "Captured CI / test env vars associated with this settings hash." }),
+	capturedAt: Schema.String.annotate({ description: "ISO-8601 timestamp the settings row was first written." })
+}).annotate({
 	identifier: "SettingsRowSchema",
 	title: "Vitest settings snapshot"
 });
 const SettingsFound = Schema.Struct({
-	found: Schema.Literal(true).annotations({ description: "Discriminant — `true` when settings were located." }),
-	source: Schema.Literal("requested", "latest").annotations({ description: "`requested` when the caller supplied `settingsHash`; `latest` when the most-recent row was returned." }),
+	found: Schema.Literal(true).annotate({ description: "Discriminant — `true` when settings were located." }),
+	source: Schema.Literals(["requested", "latest"]).annotate({ description: "`requested` when the caller supplied `settingsHash`; `latest` when the most-recent row was returned." }),
 	settings: SettingsRowSchema
-}).annotations({ identifier: "ConfigureFound" });
+}).annotate({ identifier: "ConfigureFound" });
 const SettingsAbsent = Schema.Struct({
-	found: Schema.Literal(false).annotations({ description: "Discriminant — `false` when no settings matched." }),
-	source: Schema.Literal("requested", "latest"),
-	requestedHash: Schema.optional(Schema.String).annotations({ description: "Echo of the hash the caller passed; absent when the empty `latest` lookup found nothing." })
-}).annotations({ identifier: "ConfigureAbsent" });
-const ConfigureResult = Schema.Union(SettingsFound, SettingsAbsent).annotations({
+	found: Schema.Literal(false).annotate({ description: "Discriminant — `false` when no settings matched." }),
+	source: Schema.Literals(["requested", "latest"]),
+	requestedHash: Schema.optional(Schema.String).annotate({ description: "Echo of the hash the caller passed; absent when the empty `latest` lookup found nothing." })
+}).annotate({ identifier: "ConfigureAbsent" });
+const ConfigureResult = Schema.Union([SettingsFound, SettingsAbsent]).annotate({
 	identifier: "ConfigureResult",
 	title: "configure result",
 	description: "Captured Vitest settings for a run, or an absence record when the lookup found nothing."
@@ -73,12 +70,11 @@ const formatConfigureMarkdown = (data) => {
 	].join("\n");
 	return `No settings found for hash \`${data.requestedHash ?? "(unknown)"}\`.`;
 };
-const ConfigureAsMarkdown = Schema.transformOrFail(ConfigureResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(formatConfigureMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "ConfigureAsMarkdown is one-way: markdown cannot be parsed back to ConfigureResult."))
-});
-const configure = publicProcedure.input(Schema.standardSchemaV1(Schema.Struct({ settingsHash: Schema.optional(Schema.String) }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
+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.")
+}));
+const configure = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({ settingsHash: Schema.optional(Schema.String) }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
 	const reader = yield* DataReader;
 	if (input.settingsHash === void 0) {
 		const latestOpt = yield* reader.getLatestSettings();

package/tools/coverage.js

@@ -1,6 +1,6 @@
 import { publicProcedure } from "../context.js";
 import { CoverageReport, DataReader } from "@vitest-agent/sdk";
-import { Effect, Option, ParseResult, Schema } from "effect";
+import { Effect, Option, Schema, SchemaGetter } from "effect";
 
 //#region src/tools/coverage.ts
 /**
@@ -12,12 +12,12 @@ const CoverageAvailable = Schema.Struct({
 	dataAvailable: Schema.Literal(true),
 	project: Schema.String,
 	coverage: CoverageReport
-}).annotations({ identifier: "TestCoverageAvailable" });
+}).annotate({ identifier: "TestCoverageAvailable" });
 const CoverageAbsent = Schema.Struct({
 	dataAvailable: Schema.Literal(false),
 	project: Schema.String
-}).annotations({ identifier: "TestCoverageAbsent" });
-const TestCoverageResult = Schema.Union(CoverageAvailable, CoverageAbsent).annotations({
+}).annotate({ identifier: "TestCoverageAbsent" });
+const TestCoverageResult = Schema.Union([CoverageAvailable, CoverageAbsent]).annotate({
 	identifier: "TestCoverageResult",
 	title: "test_coverage result",
 	description: "Per-project coverage report. Discriminate on `dataAvailable` for cold-start handling."
@@ -52,12 +52,11 @@ const formatTestCoverageMarkdown = (data) => {
 	} else lines.push("✅ All files meet coverage thresholds.", "");
 	return lines.join("\n");
 };
-const TestCoverageAsMarkdown = Schema.transformOrFail(TestCoverageResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(formatTestCoverageMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "TestCoverageAsMarkdown is one-way."))
-});
-const testCoverage = publicProcedure.input(Schema.standardSchemaV1(Schema.Struct({ project: Schema.optional(Schema.String) }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
+const TestCoverageAsMarkdown = TestCoverageResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform((data) => formatTestCoverageMarkdown(data)),
+	encode: SchemaGetter.forbidden(() => "TestCoverageAsMarkdown is one-way.")
+}));
+const testCoverage = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({ project: Schema.optional(Schema.String) }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
 	const reader = yield* DataReader;
 	const project = input.project ?? "default";
 	const coverageOpt = yield* reader.getCoverage(project);

package/tools/errors.js

@@ -1,6 +1,6 @@
 import { publicProcedure } from "../context.js";
 import { DataReader } from "@vitest-agent/sdk";
-import { Effect, ParseResult, Schema } from "effect";
+import { Effect, Schema, SchemaGetter } from "effect";
 
 //#region src/tools/errors.ts
 /**
@@ -11,8 +11,8 @@ import { Effect, ParseResult, Schema } from "effect";
 *   - types the procedure's return value;
 *   - drives `formatTestErrorsMarkdown` (input typed via `Schema.Type`);
 *   - composes into `TestErrorsAsMarkdown`, a one-way
-*     `Schema.transformOrFail` whose `encode` direction renders the
-*     markdown the text channel carries (decode is forbidden because
+*     `Schema.decodeTo` whose `decode` direction renders the
+*     markdown the text channel carries (encode is forbidden because
 *     markdown rendering is lossy);
 *   - bridges to zod via `effectToZodSchema` for the SDK's
 *     `outputSchema` field, so the structured shape we declare to MCP
@@ -22,39 +22,44 @@ import { Effect, ParseResult, Schema } from "effect";
 */
 /** One row in the structured `errors[]` array. */
 const TestErrorRow = Schema.Struct({
-	id: Schema.Number.annotations({
+	id: Schema.Number.annotate({
 		title: "test_errors.id",
 		description: "Numeric primary key of this error row. Pass as `citedTestErrorId` when calling `hypothesis (action: record)`."
 	}),
-	topStackFrameId: Schema.NullOr(Schema.Number).annotations({
+	topStackFrameId: Schema.NullOr(Schema.Number).annotate({
 		title: "stack_frames.id (top frame)",
 		description: "`stack_frames.id` of the top frame (ordinal=0); `null` when no frames were captured. Pass as `citedStackFrameId` to `hypothesis (action: record)`."
 	}),
-	name: Schema.NullOr(Schema.String).annotations({ description: "Error class name (e.g. `AssertionError`, `TypeError`); `null` when the underlying throw provided no name." }),
-	message: Schema.String.annotations({ description: "Error message text as the test framework reported it." }),
-	diff: Schema.NullOr(Schema.String).annotations({ description: "Unified-diff representation of expected vs. actual when the assertion produced one; `null` otherwise." }),
-	actual: Schema.NullOr(Schema.String).annotations({ description: "Actual value the assertion received, when captured." }),
-	expected: Schema.NullOr(Schema.String).annotations({ description: "Expected value the assertion compared against, when captured." }),
-	stack: Schema.NullOr(Schema.String).annotations({ description: "Newline-joined stack frames as the framework formatted them; structured frames live in `stack_frames`." }),
-	scope: Schema.Literal("test", "suite", "module", "unhandled").annotations({ description: "Where the error fired: `test` (a single test case), `suite` (a `describe` setup), `module` (collection / import time), or `unhandled` (uncaught from a background context)." }),
-	testFullName: Schema.NullOr(Schema.String).annotations({ description: "Full hierarchical test name (`describe > it`); `null` for non-test scopes (`module`, `unhandled`)." }),
-	moduleFile: Schema.NullOr(Schema.String).annotations({ description: "Repo-relative path of the test module the error originated in." })
-}).annotations({
+	name: Schema.NullOr(Schema.String).annotate({ description: "Error class name (e.g. `AssertionError`, `TypeError`); `null` when the underlying throw provided no name." }),
+	message: Schema.String.annotate({ description: "Error message text as the test framework reported it." }),
+	diff: Schema.NullOr(Schema.String).annotate({ description: "Unified-diff representation of expected vs. actual when the assertion produced one; `null` otherwise." }),
+	actual: Schema.NullOr(Schema.String).annotate({ description: "Actual value the assertion received, when captured." }),
+	expected: Schema.NullOr(Schema.String).annotate({ description: "Expected value the assertion compared against, when captured." }),
+	stack: Schema.NullOr(Schema.String).annotate({ description: "Newline-joined stack frames as the framework formatted them; structured frames live in `stack_frames`." }),
+	scope: Schema.Literals([
+		"test",
+		"suite",
+		"module",
+		"unhandled"
+	]).annotate({ description: "Where the error fired: `test` (a single test case), `suite` (a `describe` setup), `module` (collection / import time), or `unhandled` (uncaught from a background context)." }),
+	testFullName: Schema.NullOr(Schema.String).annotate({ description: "Full hierarchical test name (`describe > it`); `null` for non-test scopes (`module`, `unhandled`)." }),
+	moduleFile: Schema.NullOr(Schema.String).annotate({ description: "Repo-relative path of the test module the error originated in." })
+}).annotate({
 	identifier: "TestErrorRow",
 	title: "Test error row",
 	description: "Single error captured during a test run, joined with stack frame and source-location context."
 });
 /** Top-level structured payload — populates `structuredContent`. */
 const TestErrorsResult = Schema.Struct({
-	project: Schema.String.annotations({
+	project: Schema.String.annotate({
 		title: "Project name",
 		description: "Workspace project key the run was attributed to (e.g. `playground`, `@org/pkg`).",
 		examples: ["playground", "@org/pkg"]
 	}),
-	errorName: Schema.optional(Schema.String).annotations({ description: "Echo of the optional `errorName` filter the caller passed; absent when no filter was applied." }),
-	count: Schema.Number.annotations({ description: "Total error rows in `errors`." }),
-	errors: Schema.Array(TestErrorRow).annotations({ description: "Errors from the most recent test run for this project, optionally filtered by `errorName`. Empty when no errors matched." })
-}).annotations({
+	errorName: Schema.optional(Schema.String).annotate({ description: "Echo of the optional `errorName` filter the caller passed; absent when no filter was applied." }),
+	count: Schema.Number.annotate({ description: "Total error rows in `errors`." }),
+	errors: Schema.Array(TestErrorRow).annotate({ description: "Errors from the most recent test run for this project, optionally filtered by `errorName`. Empty when no errors matched." })
+}).annotate({
 	identifier: "TestErrorsResult",
 	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)`."
@@ -115,7 +120,7 @@ const formatTestErrorsMarkdown = (data) => {
 /**
 * One-way codec: structured `TestErrorsResult` → markdown text.
 *
-* `Schema.transformOrFail`'s `decode` direction goes
+* `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
@@ -129,12 +134,11 @@ const formatTestErrorsMarkdown = (data) => {
 * suites can drive the same path without mocking anything — the
 * transform IS the rendering contract.
 */
-const TestErrorsAsMarkdown = Schema.transformOrFail(TestErrorsResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(formatTestErrorsMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "TestErrorsAsMarkdown is one-way: markdown cannot be parsed back to TestErrorsResult. Consume the procedure's structured output (or MCP structuredContent) directly."))
-});
-const testErrors = publicProcedure.input(Schema.standardSchemaV1(Schema.Struct({
+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.")
+}));
+const testErrors = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({
 	project: Schema.String,
 	errorName: Schema.optional(Schema.String)
 }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {

package/tools/failure-signature-get.js

@@ -1,6 +1,6 @@
 import { publicProcedure } from "../context.js";
 import { DataReader } from "@vitest-agent/sdk";
-import { Effect, Option, ParseResult, Schema } from "effect";
+import { Effect, Option, Schema, SchemaGetter } from "effect";
 
 //#region src/tools/failure-signature-get.ts
 /**
@@ -14,22 +14,22 @@ const RecentError = Schema.Struct({
 	message: Schema.String
 });
 const SignatureFound = Schema.Struct({
-	found: Schema.Literal(true).annotations({ description: "Discriminant — `true` when a signature row matched." }),
-	signatureHash: Schema.String.annotations({
+	found: Schema.Literal(true).annotate({ description: "Discriminant — `true` when a signature row matched." }),
+	signatureHash: Schema.String.annotate({
 		title: "failure_signatures.signature_hash",
 		description: "16-char SHA-256 over (error_name, normalized assertion shape, top-frame function name, function-boundary line)."
 	}),
 	firstSeenRunId: Schema.NullOr(Schema.Number),
 	firstSeenAt: Schema.String,
 	lastSeenAt: Schema.NullOr(Schema.String),
-	occurrenceCount: Schema.Number.annotations({ description: "Total times this signature has been observed." }),
+	occurrenceCount: Schema.Number.annotate({ description: "Total times this signature has been observed." }),
 	recentErrors: Schema.Array(RecentError)
 });
 const SignatureMissing = Schema.Struct({
 	found: Schema.Literal(false),
 	requestedHash: Schema.String
 });
-const FailureSignatureGetResult = Schema.Union(SignatureFound, SignatureMissing).annotations({
+const FailureSignatureGetResult = Schema.Union([SignatureFound, SignatureMissing]).annotate({
 	identifier: "FailureSignatureGetResult",
 	title: "failure_signature_get result",
 	description: "Discriminate on `found`. Found rows carry first/last-seen timestamps and recent occurrences."
@@ -52,12 +52,11 @@ const formatFailureSignatureMarkdown = (data) => {
 	}
 	return lines.join("\n");
 };
-const FailureSignatureGetAsMarkdown = Schema.transformOrFail(FailureSignatureGetResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(formatFailureSignatureMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "FailureSignatureGetAsMarkdown is one-way."))
-});
-const failureSignatureGet = publicProcedure.input(Schema.standardSchemaV1(Schema.Struct({ hash: Schema.String }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
+const FailureSignatureGetAsMarkdown = FailureSignatureGetResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform((data) => formatFailureSignatureMarkdown(data)),
+	encode: SchemaGetter.forbidden(() => "FailureSignatureGetAsMarkdown is one-way.")
+}));
+const failureSignatureGet = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({ hash: Schema.String }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
 	const opt = yield* (yield* DataReader).getFailureSignatureByHash(input.hash);
 	if (Option.isNone(opt)) return {
 		found: false,