@vitest-agent/mcp 1.3.6 → 2.0.0

package/tools/file-coverage.js

@@ -1,6 +1,6 @@
 import { publicProcedure } from "../context.js";
 import { CoverageTotals, DataReader, FileCoverageReport } from "@vitest-agent/sdk";
-import { Effect, Option, ParseResult, Schema } from "effect";
+import { Effect, Option, Schema, SchemaGetter } from "effect";
 
 //#region src/tools/file-coverage.ts
 /**
@@ -21,19 +21,23 @@ const FileCoverageMatched = Schema.Struct({
 	report: FileCoverageReport,
 	globalThresholds: CoverageGlobalThresholds,
 	relatedTestFiles: Schema.Array(Schema.String)
-}).annotations({ identifier: "FileCoverageMatched" });
+}).annotate({ identifier: "FileCoverageMatched" });
 const FileCoverageNoMatch = Schema.Struct({
 	dataAvailable: Schema.Literal(true),
 	matched: Schema.Literal(false),
 	filePath: Schema.String,
 	totals: CoverageTotals,
 	relatedTestFiles: Schema.Array(Schema.String)
-}).annotations({ identifier: "FileCoverageNoMatch" });
+}).annotate({ identifier: "FileCoverageNoMatch" });
 const FileCoverageAbsent = Schema.Struct({
 	dataAvailable: Schema.Literal(false),
 	filePath: Schema.String
-}).annotations({ identifier: "FileCoverageAbsent" });
-const FileCoverageResult = Schema.Union(FileCoverageMatched, FileCoverageNoMatch, FileCoverageAbsent).annotations({
+}).annotate({ identifier: "FileCoverageAbsent" });
+const FileCoverageResult = Schema.Union([
+	FileCoverageMatched,
+	FileCoverageNoMatch,
+	FileCoverageAbsent
+]).annotate({
 	identifier: "FileCoverageResult",
 	title: "file_coverage result",
 	description: "Per-file coverage with related tests. Discriminate on `dataAvailable` then on `matched`."
@@ -65,12 +69,11 @@ const formatFileCoverageMarkdown = (data) => {
 	}
 	return lines.join("\n");
 };
-const FileCoverageAsMarkdown = Schema.transformOrFail(FileCoverageResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(formatFileCoverageMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "FileCoverageAsMarkdown is one-way."))
-});
-const fileCoverage = publicProcedure.input(Schema.standardSchemaV1(Schema.Struct({
+const FileCoverageAsMarkdown = FileCoverageResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform((data) => formatFileCoverageMarkdown(data)),
+	encode: SchemaGetter.forbidden(() => "FileCoverageAsMarkdown is one-way.")
+}));
+const fileCoverage = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({
 	filePath: Schema.String,
 	project: Schema.optional(Schema.String)
 }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {

package/tools/help.js

@@ -2,7 +2,7 @@ import { publicProcedure } from "../context.js";
 import { Schema } from "effect";
 
 //#region src/tools/help.ts
-const HelpResult = Schema.Struct({ helpText: Schema.String.annotations({ description: "Markdown table of every MCP tool with parameters and a one-line description." }) }).annotations({
+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."

package/tools/history.js

@@ -1,6 +1,6 @@
 import { publicProcedure } from "../context.js";
 import { DataReader, HistoryRecord } from "@vitest-agent/sdk";
-import { Effect, ParseResult, Schema } from "effect";
+import { Effect, Schema, SchemaGetter } from "effect";
 
 //#region src/tools/history.ts
 /**
@@ -13,45 +13,45 @@ import { Effect, ParseResult, Schema } from "effect";
 * @packageDocumentation
 */
 const FlakyTestRow = Schema.Struct({
-	fullName: Schema.String.annotations({ description: "Full hierarchical test name (`describe > it`)." }),
-	modulePath: Schema.String.annotations({ description: "Project-relative test module path -- disambiguates same-named tests across files." }),
+	fullName: Schema.String.annotate({ description: "Full hierarchical test name (`describe > it`)." }),
+	modulePath: Schema.String.annotate({ description: "Project-relative test module path -- disambiguates same-named tests across files." }),
 	project: Schema.String,
-	passCount: Schema.Number.annotations({ description: "Number of passing runs in the recent window." }),
-	failCount: Schema.Number.annotations({ description: "Number of failing runs in the recent window." }),
-	lastState: Schema.Literal("passed", "failed").annotations({ description: "State of the most recent run." }),
-	lastTimestamp: Schema.String.annotations({ description: "ISO-8601 timestamp of the most recent run." })
-}).annotations({
+	passCount: Schema.Number.annotate({ description: "Number of passing runs in the recent window." }),
+	failCount: Schema.Number.annotate({ description: "Number of failing runs in the recent window." }),
+	lastState: Schema.Literals(["passed", "failed"]).annotate({ description: "State of the most recent run." }),
+	lastTimestamp: Schema.String.annotate({ description: "ISO-8601 timestamp of the most recent run." })
+}).annotate({
 	identifier: "FlakyTestRow",
 	description: "A test that produced both passes and failures within the recent run window."
 });
 const PersistentFailureRow = Schema.Struct({
 	fullName: Schema.String,
-	modulePath: Schema.String.annotations({ description: "Project-relative test module path -- disambiguates same-named tests across files." }),
+	modulePath: Schema.String.annotate({ description: "Project-relative test module path -- disambiguates same-named tests across files." }),
 	project: Schema.String,
-	consecutiveFailures: Schema.Number.annotations({ description: "Length of the current uninterrupted failure streak." }),
-	firstFailedAt: Schema.String.annotations({ description: "ISO-8601 timestamp of the first failure in this streak." }),
-	lastFailedAt: Schema.String.annotations({ description: "ISO-8601 timestamp of the most recent failure." }),
-	lastErrorMessage: Schema.NullOr(Schema.String).annotations({ description: "Last error message reported by the failing test, when captured." })
-}).annotations({
+	consecutiveFailures: Schema.Number.annotate({ description: "Length of the current uninterrupted failure streak." }),
+	firstFailedAt: Schema.String.annotate({ description: "ISO-8601 timestamp of the first failure in this streak." }),
+	lastFailedAt: Schema.String.annotate({ description: "ISO-8601 timestamp of the most recent failure." }),
+	lastErrorMessage: Schema.NullOr(Schema.String).annotate({ description: "Last error message reported by the failing test, when captured." })
+}).annotate({
 	identifier: "PersistentFailureRow",
 	description: "A test that has failed in every recent run since `firstFailedAt`."
 });
 const RecoveredTestRow = Schema.Struct({
-	modulePath: Schema.String.annotations({ description: "Project-relative test module path -- disambiguates same-named tests across files." }),
+	modulePath: Schema.String.annotate({ description: "Project-relative test module path -- disambiguates same-named tests across files." }),
 	fullName: Schema.String,
-	recentRuns: Schema.Array(Schema.Literal("passed", "failed")).annotations({ description: "Last 10 run states for this test, oldest first." })
-}).annotations({
+	recentRuns: Schema.Array(Schema.Literals(["passed", "failed"])).annotate({ description: "Last 10 run states for this test, oldest first." })
+}).annotate({
 	identifier: "RecoveredTestRow",
 	description: "A test whose latest run passed after the previous one failed."
 });
 const TestHistoryResult = Schema.Struct({
-	project: Schema.String.annotations({ description: "Workspace project key the history was computed for." }),
-	hasData: Schema.Boolean.annotations({ description: "`false` when no history rows exist for the project — agent should suggest running tests first." }),
-	history: HistoryRecord.annotations({ description: "Raw per-test history record (stored in `test_runs` joins)." }),
-	flaky: Schema.Array(FlakyTestRow).annotations({ description: "Tests with mixed pass/fail outcomes recently." }),
-	persistent: Schema.Array(PersistentFailureRow).annotations({ description: "Tests failing across consecutive runs." }),
-	recovered: Schema.Array(RecoveredTestRow).annotations({ description: "Tests that just transitioned from failing to passing in the last run." })
-}).annotations({
+	project: Schema.String.annotate({ description: "Workspace project key the history was computed for." }),
+	hasData: Schema.Boolean.annotate({ description: "`false` when no history rows exist for the project — agent should suggest running tests first." }),
+	history: HistoryRecord.annotate({ description: "Raw per-test history record (stored in `test_runs` joins)." }),
+	flaky: Schema.Array(FlakyTestRow).annotate({ description: "Tests with mixed pass/fail outcomes recently." }),
+	persistent: Schema.Array(PersistentFailureRow).annotate({ description: "Tests failing across consecutive runs." }),
+	recovered: Schema.Array(RecoveredTestRow).annotate({ description: "Tests that just transitioned from failing to passing in the last run." })
+}).annotate({
 	identifier: "TestHistoryResult",
 	title: "test_history result",
 	description: "Per-project flaky/persistent/recovered test classifications computed from `test_runs` history."
@@ -87,12 +87,11 @@ const formatTestHistoryMarkdown = (data) => {
 	lines.push(`_History updated: ${data.history.updatedAt}_`);
 	return lines.join("\n");
 };
-const TestHistoryAsMarkdown = Schema.transformOrFail(TestHistoryResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(formatTestHistoryMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "TestHistoryAsMarkdown is one-way: markdown cannot be parsed back to TestHistoryResult."))
-});
-const testHistory = publicProcedure.input(Schema.standardSchemaV1(Schema.Struct({ project: Schema.String }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
+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.")
+}));
+const testHistory = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({ project: Schema.String }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
 	const reader = yield* DataReader;
 	const [history, flaky, persistent] = yield* Effect.all([
 		reader.getHistory(input.project),

package/tools/hypothesis.js

@@ -16,15 +16,19 @@ import { Effect, Match, Option, Schema } from "effect";
 const HypothesisRowSchema = Schema.Struct({
 	id: Schema.Number,
 	sessionId: Schema.Number,
-	content: Schema.String.annotations({ description: "Free-text hypothesis the agent recorded before attempting a fix." }),
-	citedTestErrorId: Schema.NullOr(Schema.Number).annotations({ description: "Optional `test_errors.id` the hypothesis cites as the failing observation." }),
-	citedStackFrameId: Schema.NullOr(Schema.Number).annotations({ description: "Optional `stack_frames.id` for the specific frame the hypothesis blames." }),
-	validationOutcome: Schema.NullOr(Schema.Literal("confirmed", "refuted", "abandoned")).annotations({ description: "Outcome recorded by `hypothesis (action: validate)`; `null` while still open." }),
-	validatedAt: Schema.NullOr(Schema.String).annotations({ description: "ISO-8601 validation timestamp; `null` while open." })
-}).annotations({ identifier: "HypothesisRow" });
+	content: Schema.String.annotate({ description: "Free-text hypothesis the agent recorded before attempting a fix." }),
+	citedTestErrorId: Schema.NullOr(Schema.Number).annotate({ description: "Optional `test_errors.id` the hypothesis cites as the failing observation." }),
+	citedStackFrameId: Schema.NullOr(Schema.Number).annotate({ description: "Optional `stack_frames.id` for the specific frame the hypothesis blames." }),
+	validationOutcome: Schema.NullOr(Schema.Literals([
+		"confirmed",
+		"refuted",
+		"abandoned"
+	])).annotate({ description: "Outcome recorded by `hypothesis (action: validate)`; `null` while still open." }),
+	validatedAt: Schema.NullOr(Schema.String).annotate({ description: "ISO-8601 validation timestamp; `null` while open." })
+}).annotate({ identifier: "HypothesisRow" });
 const HypothesisRecordOk = Schema.Struct({
 	action: Schema.Literal("record"),
-	id: Schema.Number.annotations({ description: "Newly inserted hypothesis row primary key." })
+	id: Schema.Number.annotate({ description: "Newly inserted hypothesis row primary key." })
 });
 const HypothesisValidateOk = Schema.Struct({ action: Schema.Literal("validate") });
 const HypothesisListOk = Schema.Struct({
@@ -32,7 +36,11 @@ const HypothesisListOk = Schema.Struct({
 	count: Schema.Number,
 	hypotheses: Schema.Array(HypothesisRowSchema)
 });
-const HypothesisResult = Schema.Union(HypothesisRecordOk, HypothesisValidateOk, HypothesisListOk).annotations({
+const HypothesisResult = Schema.Union([
+	HypothesisRecordOk,
+	HypothesisValidateOk,
+	HypothesisListOk
+]).annotate({
 	identifier: "HypothesisResult",
 	title: "hypothesis result",
 	description: "Discriminate on `action`. record returns the new id; list returns the matching rows; validate returns an empty acknowledgement."
@@ -58,18 +66,31 @@ const RecordVariant = Schema.Struct({
 const ValidateVariant = Schema.Struct({
 	action: Schema.Literal("validate"),
 	id: Schema.Number,
-	outcome: Schema.Literal("confirmed", "refuted", "abandoned"),
+	outcome: Schema.Literals([
+		"confirmed",
+		"refuted",
+		"abandoned"
+	]),
 	validatedTurnId: Schema.optional(Schema.Number),
 	validatedAt: Schema.String
 });
 const ListVariant = Schema.Struct({
 	action: Schema.Literal("list"),
 	sessionId: Schema.optional(Schema.Number),
-	outcome: Schema.optional(Schema.Literal("confirmed", "refuted", "abandoned", "open")),
+	outcome: Schema.optional(Schema.Literals([
+		"confirmed",
+		"refuted",
+		"abandoned",
+		"open"
+	])),
 	limit: Schema.optional(Schema.Number)
 });
-const HypothesisInput = Schema.Union(RecordVariant, ValidateVariant, ListVariant);
-const hypothesis = idempotentProcedure.input(Schema.standardSchemaV1(HypothesisInput)).mutation(async ({ ctx, input }) => {
+const HypothesisInput = Schema.Union([
+	RecordVariant,
+	ValidateVariant,
+	ListVariant
+]);
+const hypothesis = idempotentProcedure.input(Schema.toStandardSchemaV1(HypothesisInput)).mutation(async ({ ctx, input }) => {
 	return ctx.runtime.runPromise(Match.value(input).pipe(Match.discriminatorsExhaustive("action")({
 		record: (variant) => Effect.gen(function* () {
 			const store = yield* DataStore;

package/tools/inventory.js

@@ -1,6 +1,6 @@
 import { publicProcedure } from "../context.js";
 import { DataReader } from "@vitest-agent/sdk";
-import { Effect, Match, Option, ParseResult, Schema } from "effect";
+import { Effect, Match, Option, Schema, SchemaGetter } from "effect";
 
 //#region src/tools/inventory.ts
 /**
@@ -18,44 +18,48 @@ import { Effect, Match, Option, ParseResult, Schema } from "effect";
 const ProjectRunSummary = Schema.Struct({
 	project: Schema.String,
 	lastRun: Schema.NullOr(Schema.String),
-	lastResult: Schema.NullOr(Schema.Literal("passed", "failed", "interrupted")),
+	lastResult: Schema.NullOr(Schema.Literals([
+		"passed",
+		"failed",
+		"interrupted"
+	])),
 	total: Schema.Number,
 	passed: Schema.Number,
 	failed: Schema.Number,
 	skipped: Schema.Number
-}).annotations({ identifier: "InventoryProjectRow" });
+}).annotate({ identifier: "InventoryProjectRow" });
 const ModuleRow = Schema.Struct({
 	id: Schema.Number,
 	file: Schema.String,
 	state: Schema.String,
 	testCount: Schema.Number,
 	duration: Schema.NullOr(Schema.Number)
-}).annotations({ identifier: "InventoryModuleRow" });
+}).annotate({ identifier: "InventoryModuleRow" });
 const SuiteRow = Schema.Struct({
 	id: Schema.Number,
 	name: Schema.String,
 	module: Schema.String,
 	state: Schema.String,
 	testCount: Schema.Number
-}).annotations({ identifier: "InventorySuiteRow" });
+}).annotate({ identifier: "InventorySuiteRow" });
 const SessionRow = Schema.Struct({
 	id: Schema.Number,
 	chatId: Schema.String,
 	project: Schema.String,
 	cwd: Schema.String,
-	agentKind: Schema.Literal("main", "subagent"),
+	agentKind: Schema.Literals(["main", "subagent"]),
 	agentType: Schema.NullOr(Schema.String),
 	parentSessionId: Schema.NullOr(Schema.Number),
 	triageWasNonEmpty: Schema.Boolean,
 	startedAt: Schema.String,
 	endedAt: Schema.NullOr(Schema.String),
 	endReason: Schema.NullOr(Schema.String)
-}).annotations({ identifier: "InventorySessionRow" });
+}).annotate({ identifier: "InventorySessionRow" });
 const ProjectInventory = Schema.Struct({
 	inventoryKind: Schema.Literal("project"),
 	count: Schema.Number,
 	projects: Schema.Array(ProjectRunSummary)
-}).annotations({ identifier: "ProjectInventory" });
+}).annotate({ identifier: "ProjectInventory" });
 const ModuleGroup = Schema.Struct({
 	project: Schema.String,
 	modules: Schema.Array(ModuleRow)
@@ -64,7 +68,7 @@ const ModuleInventory = Schema.Struct({
 	inventoryKind: Schema.Literal("module"),
 	count: Schema.Number,
 	groups: Schema.Array(ModuleGroup)
-}).annotations({ identifier: "ModuleInventory" });
+}).annotate({ identifier: "ModuleInventory" });
 const SuiteGroup = Schema.Struct({
 	project: Schema.String,
 	suites: Schema.Array(SuiteRow)
@@ -73,50 +77,59 @@ const SuiteInventory = Schema.Struct({
 	inventoryKind: Schema.Literal("suite"),
 	count: Schema.Number,
 	groups: Schema.Array(SuiteGroup)
-}).annotations({ identifier: "SuiteInventory" });
+}).annotate({ identifier: "SuiteInventory" });
 const SessionDetailFound = Schema.Struct({
 	inventoryKind: Schema.Literal("session_detail"),
 	found: Schema.Literal(true),
 	session: SessionRow
-}).annotations({ identifier: "SessionDetailFound" });
+}).annotate({ identifier: "SessionDetailFound" });
 const SessionDetailMissing = Schema.Struct({
 	inventoryKind: Schema.Literal("session_detail"),
 	found: Schema.Literal(false),
 	id: Schema.Number
-}).annotations({ identifier: "SessionDetailMissing" });
+}).annotate({ identifier: "SessionDetailMissing" });
 const SessionListInventory = Schema.Struct({
 	inventoryKind: Schema.Literal("session_list"),
 	count: Schema.Number,
 	sessions: Schema.Array(SessionRow)
-}).annotations({ identifier: "SessionListInventory" });
+}).annotate({ identifier: "SessionListInventory" });
 const TagProjectBreakdown = Schema.Struct({
 	project: Schema.String,
 	moduleCount: Schema.Number,
 	testCount: Schema.Number
-}).annotations({ identifier: "TagProjectBreakdown" });
+}).annotate({ identifier: "TagProjectBreakdown" });
 const TagRowScoped = Schema.Struct({
 	tag: Schema.String,
 	moduleCount: Schema.Number,
 	testCount: Schema.Number
-}).annotations({ identifier: "TagRowScoped" });
+}).annotate({ identifier: "TagRowScoped" });
 const TagRowUnscoped = Schema.Struct({
 	tag: Schema.String,
 	moduleCount: Schema.Number,
 	testCount: Schema.Number,
 	byProject: Schema.Array(TagProjectBreakdown)
-}).annotations({ identifier: "TagRowUnscoped" });
+}).annotate({ identifier: "TagRowUnscoped" });
 const TagInventoryScoped = Schema.Struct({
 	inventoryKind: Schema.Literal("tag_scoped"),
 	project: Schema.String,
 	count: Schema.Number,
 	tags: Schema.Array(TagRowScoped)
-}).annotations({ identifier: "TagInventoryScoped" });
+}).annotate({ identifier: "TagInventoryScoped" });
 const TagInventoryUnscoped = Schema.Struct({
 	inventoryKind: Schema.Literal("tag_unscoped"),
 	count: Schema.Number,
 	tags: Schema.Array(TagRowUnscoped)
-}).annotations({ identifier: "TagInventoryUnscoped" });
-const InventoryResult = Schema.Union(ProjectInventory, ModuleInventory, SuiteInventory, SessionDetailFound, SessionDetailMissing, SessionListInventory, TagInventoryScoped, TagInventoryUnscoped).annotations({
+}).annotate({ identifier: "TagInventoryUnscoped" });
+const InventoryResult = Schema.Union([
+	ProjectInventory,
+	ModuleInventory,
+	SuiteInventory,
+	SessionDetailFound,
+	SessionDetailMissing,
+	SessionListInventory,
+	TagInventoryScoped,
+	TagInventoryUnscoped
+]).annotate({
 	identifier: "InventoryResult",
 	title: "inventory result",
 	description: "Discriminate on `inventoryKind`. project/module/suite carry counted lists; session_detail discriminates further on `found`; session_list returns the matching sessions; tag_scoped and tag_unscoped carry per-tag counts (the unscoped form also carries a `byProject` breakdown per tag)."
@@ -209,11 +222,10 @@ const formatInventoryMarkdown = (data) => {
 	}
 	return lines.join("\n");
 };
-const InventoryAsMarkdown = Schema.transformOrFail(InventoryResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(formatInventoryMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "InventoryAsMarkdown is one-way."))
-});
+const 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"),
@@ -228,15 +240,21 @@ const SessionVariant = Schema.Struct({
 	kind: Schema.Literal("session"),
 	id: Schema.optional(Schema.Number),
 	project: Schema.optional(Schema.String),
-	agentKind: Schema.optional(Schema.Literal("main", "subagent")),
+	agentKind: Schema.optional(Schema.Literals(["main", "subagent"])),
 	limit: Schema.optional(Schema.Number)
 });
 const TagVariant = Schema.Struct({
 	kind: Schema.Literal("tag"),
 	project: Schema.optional(Schema.String)
 });
-const InventoryInput = Schema.Union(ProjectVariant, ModuleVariant, SuiteVariant, SessionVariant, TagVariant);
-const inventory = publicProcedure.input(Schema.standardSchemaV1(InventoryInput)).query(async ({ ctx, input }) => {
+const InventoryInput = Schema.Union([
+	ProjectVariant,
+	ModuleVariant,
+	SuiteVariant,
+	SessionVariant,
+	TagVariant
+]);
+const inventory = publicProcedure.input(Schema.toStandardSchemaV1(InventoryInput)).query(async ({ ctx, input }) => {
 	return ctx.runtime.runPromise(Match.value(input).pipe(Match.discriminatorsExhaustive("kind")({
 		project: () => Effect.gen(function* () {
 			const projects = yield* (yield* DataReader).getRunsByProject();

package/tools/note.js

@@ -3,12 +3,19 @@ import { DataReader, DataStore } from "@vitest-agent/sdk";
 import { Effect, Match, Option, Schema } from "effect";
 
 //#region src/tools/note.ts
-const NoteScope = Schema.Literal("global", "project", "module", "suite", "test", "note");
+const NoteScope = Schema.Literals([
+	"global",
+	"project",
+	"module",
+	"suite",
+	"test",
+	"note"
+]);
 const NoteRowSchema = Schema.Struct({
-	id: Schema.Number.annotations({ description: "Note primary key." }),
+	id: Schema.Number.annotate({ description: "Note primary key." }),
 	title: Schema.String,
 	content: Schema.String,
-	scope: NoteScope.annotations({ description: "`global` (project-agnostic), `project`, `module`, `suite`, `test` (scoped), or `note` (child note attached via `parentNoteId`)." }),
+	scope: NoteScope.annotate({ description: "`global` (project-agnostic), `project`, `module`, `suite`, `test` (scoped), or `note` (child note attached via `parentNoteId`)." }),
 	project: Schema.NullOr(Schema.String),
 	testFullName: Schema.NullOr(Schema.String),
 	modulePath: Schema.NullOr(Schema.String),
@@ -18,15 +25,15 @@ const NoteRowSchema = Schema.Struct({
 	pinned: Schema.Boolean,
 	createdAt: Schema.String,
 	updatedAt: Schema.String
-}).annotations({ identifier: "NoteRow" });
+}).annotate({ identifier: "NoteRow" });
 const NoteCreateOk = Schema.Struct({
 	action: Schema.Literal("create"),
-	id: Schema.Number.annotations({ description: "Primary key of the newly inserted note." })
+	id: Schema.Number.annotate({ description: "Primary key of the newly inserted note." })
 });
 const NoteListOk = Schema.Struct({
 	action: Schema.Literal("list"),
 	count: Schema.Number,
-	notes: Schema.Array(NoteRowSchema).annotations({ description: "Notes matching the optional scope/project/test filters." })
+	notes: Schema.Array(NoteRowSchema).annotate({ description: "Notes matching the optional scope/project/test filters." })
 });
 const NoteGetFound = Schema.Struct({
 	action: Schema.Literal("get"),
@@ -50,9 +57,17 @@ const NoteSearchOk = Schema.Struct({
 	action: Schema.Literal("search"),
 	query: Schema.String,
 	count: Schema.Number,
-	notes: Schema.Array(NoteRowSchema).annotations({ description: "Notes whose title or content match the FTS5 query." })
+	notes: Schema.Array(NoteRowSchema).annotate({ description: "Notes whose title or content match the FTS5 query." })
 });
-const NoteResult = Schema.Union(NoteCreateOk, NoteListOk, NoteGetFound, NoteGetMissing, NoteUpdateOk, NoteDeleteOk, NoteSearchOk).annotations({
+const NoteResult = Schema.Union([
+	NoteCreateOk,
+	NoteListOk,
+	NoteGetFound,
+	NoteGetMissing,
+	NoteUpdateOk,
+	NoteDeleteOk,
+	NoteSearchOk
+]).annotate({
 	identifier: "NoteResult",
 	title: "note result",
 	description: "Discriminate on `action`. `get` further discriminates on `found`."
@@ -129,8 +144,15 @@ const SearchVariant = Schema.Struct({
 	action: Schema.Literal("search"),
 	query: Schema.String
 });
-const NoteInputUnion = Schema.Union(CreateVariant, ListVariant, GetVariant, UpdateVariant, DeleteVariant, SearchVariant);
-const note = publicProcedure.input(Schema.standardSchemaV1(NoteInputUnion)).mutation(async ({ ctx, input }) => {
+const NoteInputUnion = Schema.Union([
+	CreateVariant,
+	ListVariant,
+	GetVariant,
+	UpdateVariant,
+	DeleteVariant,
+	SearchVariant
+]);
+const note = publicProcedure.input(Schema.toStandardSchemaV1(NoteInputUnion)).mutation(async ({ ctx, input }) => {
 	return ctx.runtime.runPromise(Match.value(input).pipe(Match.discriminatorsExhaustive("action")({
 		create: (variant) => Effect.gen(function* () {
 			const store = yield* DataStore;

package/tools/overview.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/overview.ts
 /**
@@ -11,12 +11,16 @@ import { Effect, Option, ParseResult, Schema } from "effect";
 const ProjectRunSummary = Schema.Struct({
 	project: Schema.String,
 	lastRun: Schema.NullOr(Schema.String),
-	lastResult: Schema.NullOr(Schema.Literal("passed", "failed", "interrupted")),
+	lastResult: Schema.NullOr(Schema.Literals([
+		"passed",
+		"failed",
+		"interrupted"
+	])),
 	total: Schema.Number,
 	passed: Schema.Number,
 	failed: Schema.Number,
 	skipped: Schema.Number
-}).annotations({
+}).annotate({
 	identifier: "ProjectRunSummary",
 	description: "One row per project's most recent run summary."
 });
@@ -24,13 +28,13 @@ const OverviewAvailable = Schema.Struct({
 	dataAvailable: Schema.Literal(true),
 	projectFilter: Schema.optional(Schema.String),
 	runs: Schema.Array(ProjectRunSummary)
-}).annotations({ identifier: "TestOverviewAvailable" });
+}).annotate({ identifier: "TestOverviewAvailable" });
 const OverviewAbsent = Schema.Struct({
 	dataAvailable: Schema.Literal(false),
 	projectFilter: Schema.optional(Schema.String),
-	reason: Schema.Literal("no_runs", "project_filter_empty")
-}).annotations({ identifier: "TestOverviewAbsent" });
-const TestOverviewResult = Schema.Union(OverviewAvailable, OverviewAbsent).annotations({
+	reason: Schema.Literals(["no_runs", "project_filter_empty"])
+}).annotate({ identifier: "TestOverviewAbsent" });
+const TestOverviewResult = Schema.Union([OverviewAvailable, OverviewAbsent]).annotate({
 	identifier: "TestOverviewResult",
 	title: "test_overview result",
 	description: "Per-project run metrics. Discriminate on `dataAvailable` for cold-start handling."
@@ -62,12 +66,11 @@ const formatTestOverviewMarkdown = (data) => {
 	}
 	return lines.join("\n");
 };
-const TestOverviewAsMarkdown = Schema.transformOrFail(TestOverviewResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(formatTestOverviewMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "TestOverviewAsMarkdown is one-way."))
-});
-const testOverview = publicProcedure.input(Schema.standardSchemaV1(Schema.Struct({ project: Schema.optional(Schema.String) }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
+const TestOverviewAsMarkdown = TestOverviewResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform((data) => formatTestOverviewMarkdown(data)),
+	encode: SchemaGetter.forbidden(() => "TestOverviewAsMarkdown is one-way.")
+}));
+const testOverview = 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 [manifestOpt, runs] = yield* Effect.all([reader.getManifest(), reader.getRunsByProject()]);
 	if (Option.isNone(manifestOpt) || runs.length === 0) return {

package/tools/ping.js

@@ -11,7 +11,7 @@ import { Schema } from "effect";
 *
 * @packageDocumentation
 */
-const PingResult = Schema.Struct({ message: Schema.Literal("pong").annotations({ description: "Constant `pong`. Presence confirms the MCP server responded." }) }).annotations({
+const PingResult = Schema.Struct({ message: Schema.Literal("pong").annotate({ description: "Constant `pong`. Presence confirms the MCP server responded." }) }).annotate({
 	identifier: "PingResult",
 	title: "ping result",
 	description: "Liveness probe. Carries no data beyond the constant `pong` discriminant."

package/tools/register-agent.js

@@ -43,29 +43,34 @@ const RegisterAgentInput = Schema.Struct({
 	startWorktreeDir: Schema.optional(Schema.String)
 });
 const RegisterAgentSuccess = Schema.Struct({
-	ok: Schema.Literal(true).annotations({ description: "Discriminant — `true` when the agent row was inserted (or an existing one recovered)." }),
-	agentId: Schema.String.annotations({
+	ok: Schema.Literal(true).annotate({ description: "Discriminant — `true` when the agent row was inserted (or an existing one recovered)." }),
+	agentId: Schema.String.annotate({
 		title: "agents.agent_id",
 		description: "Canonical UUID for the registered agent — pass to subsequent attribution-bearing calls."
 	}),
-	conversationId: Schema.NullOr(Schema.String).annotations({ description: "Conversation UUID from the host's transcript when one was supplied; `null` otherwise." }),
-	idempotencyKey: Schema.String.annotations({ description: "26-char base32 SHA-256 of (agentType, parentAgentId|sentinel, clientNonce). Stable across retries with identical input." })
-}).annotations({ identifier: "RegisterAgentSuccess" });
+	conversationId: Schema.NullOr(Schema.String).annotate({ description: "Conversation UUID from the host's transcript when one was supplied; `null` otherwise." }),
+	idempotencyKey: Schema.String.annotate({ description: "26-char base32 SHA-256 of (agentType, parentAgentId|sentinel, clientNonce). Stable across retries with identical input." })
+}).annotate({ identifier: "RegisterAgentSuccess" });
 const RegisterAgentFailure = Schema.Struct({
-	ok: Schema.Literal(false).annotations({ description: "Discriminant — `false` when registration was refused." }),
+	ok: Schema.Literal(false).annotate({ description: "Discriminant — `false` when registration was refused." }),
 	error: Schema.Struct({
-		code: Schema.Literal("AGENT_ALREADY_REGISTERED", "PARENT_AGENT_NOT_FOUND", "SESSION_NOT_FOUND", "INVALID_AGENT_TYPE_PREFIX").annotations({ description: "Refusal reason. AGENT_ALREADY_REGISTERED carries `existingAgentId` so the caller can recover. INVALID_AGENT_TYPE_PREFIX carries `expectedPrefix`." }),
-		message: Schema.String.annotations({ description: "Human-readable refusal explanation." }),
-		existingAgentId: Schema.optional(Schema.String).annotations({ description: "Present only when `code = AGENT_ALREADY_REGISTERED`. Use this id instead of registering a new one." }),
-		expectedPrefix: Schema.optional(Schema.String).annotations({ description: "Present only when `code = INVALID_AGENT_TYPE_PREFIX`. The required `<hostKind>-` prefix." })
+		code: Schema.Literals([
+			"AGENT_ALREADY_REGISTERED",
+			"PARENT_AGENT_NOT_FOUND",
+			"SESSION_NOT_FOUND",
+			"INVALID_AGENT_TYPE_PREFIX"
+		]).annotate({ description: "Refusal reason. AGENT_ALREADY_REGISTERED carries `existingAgentId` so the caller can recover. INVALID_AGENT_TYPE_PREFIX carries `expectedPrefix`." }),
+		message: Schema.String.annotate({ description: "Human-readable refusal explanation." }),
+		existingAgentId: Schema.optional(Schema.String).annotate({ description: "Present only when `code = AGENT_ALREADY_REGISTERED`. Use this id instead of registering a new one." }),
+		expectedPrefix: Schema.optional(Schema.String).annotate({ description: "Present only when `code = INVALID_AGENT_TYPE_PREFIX`. The required `<hostKind>-` prefix." })
 	})
-}).annotations({ identifier: "RegisterAgentFailure" });
-const RegisterAgentResult = Schema.Union(RegisterAgentSuccess, RegisterAgentFailure).annotations({
+}).annotate({ identifier: "RegisterAgentFailure" });
+const RegisterAgentResult = Schema.Union([RegisterAgentSuccess, RegisterAgentFailure]).annotate({
 	identifier: "RegisterAgentResult",
 	title: "register_agent result",
 	description: "Discriminate on `ok`. The four failure codes are documented per their `code` literal."
 });
-const registerAgent = publicProcedure.input(Schema.standardSchemaV1(RegisterAgentInput)).mutation(async ({ ctx, input }) => {
+const registerAgent = publicProcedure.input(Schema.toStandardSchemaV1(RegisterAgentInput)).mutation(async ({ ctx, input }) => {
 	const expectedPrefix = `${input.hostKind ?? "claude-code"}-`;
 	if (!input.agentType.startsWith(expectedPrefix)) return {
 		ok: false,