@vitest-agent/mcp 1.3.6 → 2.0.1

package/tools/run-tests.js

@@ -1,46 +1,48 @@
 import { publicProcedure } from "../context.js";
 import { AgentReport, DataReader, DataStore, buildAgentReport, buildConsoleLeaks, collectConsoleLeakEntries } from "@vitest-agent/sdk";
-import { Effect, ParseResult, Schema } from "effect";
+import { Effect, Schema, SchemaGetter } from "effect";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { Writable } from "node:stream";
 
 //#region src/tools/run-tests.ts
 const RunTestsOk = Schema.Struct({
-	kind: Schema.Literal("ok").annotations({ description: "Discriminant — `true` test run completed (with or without failures)." }),
+	kind: Schema.Literal("ok").annotate({ description: "Discriminant — `true` test run completed (with or without failures)." }),
 	project: Schema.optional(Schema.String),
-	report: AgentReport.annotations({ description: "Full AgentReport including pass/fail counts and per-module errors." }),
-	classifications: Schema.Record({
-		key: Schema.String,
-		value: Schema.String
-	}).annotations({ description: "Per-test classification labels: stable, new-failure, persistent, flaky, recovered." }),
-	discoveryLastScannedAt: Schema.optional(Schema.NullOr(Schema.String)).annotations({ description: "ISO timestamp of the most recent real disk scan performed by discoverProjects() in this process (issue #100). `null`/absent means discovery has not scanned disk in this process yet (e.g. a config that doesn't call AgentPlugin.discover()). A stale-looking test count is self-explaining when compared against this value." })
-}).annotations({ identifier: "RunTestsOk" });
+	report: AgentReport.annotate({ description: "Full AgentReport including pass/fail counts and per-module errors." }),
+	classifications: Schema.Record(Schema.String, Schema.String).annotate({ description: "Per-test classification labels: stable, new-failure, persistent, flaky, recovered." }),
+	discoveryLastScannedAt: Schema.optional(Schema.NullOr(Schema.String)).annotate({ description: "ISO timestamp of the most recent real disk scan performed by discoverProjects() in this process (issue #100). `null`/absent means discovery has not scanned disk in this process yet (e.g. a config that doesn't call AgentPlugin.discover()). A stale-looking test count is self-explaining when compared against this value." })
+}).annotate({ identifier: "RunTestsOk" });
 const RunTestsTimeout = Schema.Struct({
 	kind: Schema.Literal("timeout"),
 	timeoutSeconds: Schema.Number
-}).annotations({ identifier: "RunTestsTimeout" });
+}).annotate({ identifier: "RunTestsTimeout" });
 const RunTestsError = Schema.Struct({
 	kind: Schema.Literal("error"),
 	message: Schema.String
-}).annotations({ identifier: "RunTestsError" });
+}).annotate({ identifier: "RunTestsError" });
 const TagFilter = Schema.Struct({
 	all: Schema.optional(Schema.Array(Schema.String)),
 	any: Schema.optional(Schema.Array(Schema.String)),
 	none: Schema.optional(Schema.Array(Schema.String))
-}).annotations({
+}).annotate({
 	identifier: "TagFilter",
 	description: "All three sub-filters AND together with `project` and `files`. `all` requires every listed tag on the test. `any` requires at least one. `none` excludes any test carrying a listed tag."
 });
 const RunTestsNoMatch = Schema.Struct({
-	kind: Schema.Literal("no-match").annotations({ description: "Discriminant — the resolved filter set matched zero test cases. Tests did not run; this is independent of passWithNoTests policy." }),
+	kind: Schema.Literal("no-match").annotate({ description: "Discriminant — the resolved filter set matched zero test cases. Tests did not run; this is independent of passWithNoTests policy." }),
 	filter: Schema.Struct({
 		project: Schema.NullOr(Schema.String),
 		files: Schema.Array(Schema.String),
 		tags: Schema.NullOr(TagFilter),
 		resolvedExpression: Schema.NullOr(Schema.String)
 	})
-}).annotations({ identifier: "RunTestsNoMatch" });
-const RunTestsResult = Schema.Union(RunTestsOk, RunTestsTimeout, RunTestsError, RunTestsNoMatch).annotations({
+}).annotate({ identifier: "RunTestsNoMatch" });
+const RunTestsResult = Schema.Union([
+	RunTestsOk,
+	RunTestsTimeout,
+	RunTestsError,
+	RunTestsNoMatch
+]).annotate({
 	identifier: "RunTestsResult",
 	title: "run_tests result",
 	description: "Discriminate on `kind`. ok carries the full AgentReport plus per-test classifications; timeout / error are the two failure modes; no-match indicates that the resolved filter set matched zero test cases."
@@ -194,11 +196,10 @@ function formatNoMatchMarkdown(filter) {
 	if (filter.project !== null) lines.push("- Verify the project name with `inventory({ kind: \"project\" })`");
 	return lines.join("\n");
 }
-const RunTestsAsMarkdown = Schema.transformOrFail(RunTestsResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(formatRunTestsMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "RunTestsAsMarkdown is one-way."))
-});
+const RunTestsAsMarkdown = RunTestsResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform((data) => formatRunTestsMarkdown(data)),
+	encode: SchemaGetter.forbidden(() => "RunTestsAsMarkdown is one-way.")
+}));
 /**
 * Format an AgentReport as concise markdown suitable for MCP tool output.
 *
@@ -270,7 +271,7 @@ function formatReportMarkdown(report, classifications) {
 	}
 	return lines.join("\n");
 }
-const runTests = publicProcedure.input(Schema.standardSchemaV1(Schema.Struct({
+const runTests = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({
 	files: Schema.optional(Schema.Array(Schema.String)),
 	project: Schema.optional(Schema.String),
 	tags: Schema.optional(TagFilter),

package/tools/settings-list.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/settings-list.ts
 /**
@@ -9,13 +9,13 @@ import { Effect, ParseResult, Schema } from "effect";
 * @packageDocumentation
 */
 const SettingsRow = Schema.Struct({
-	hash: Schema.String.annotations({ description: "Stable SHA-1 of the captured Vitest settings; FK target on test_runs." }),
-	capturedAt: Schema.String.annotations({ description: "ISO-8601 timestamp the settings row was first written." })
-}).annotations({ identifier: "SettingsListRow" });
+	hash: Schema.String.annotate({ description: "Stable SHA-1 of the captured Vitest settings; FK target on test_runs." }),
+	capturedAt: Schema.String.annotate({ description: "ISO-8601 timestamp the settings row was first written." })
+}).annotate({ identifier: "SettingsListRow" });
 const SettingsListResult = Schema.Struct({
 	count: Schema.Number,
-	settings: Schema.Array(SettingsRow).annotations({ description: "Distinct captured settings hashes the reporter has written, newest first." })
-}).annotations({
+	settings: Schema.Array(SettingsRow).annotate({ description: "Distinct captured settings hashes the reporter has written, newest first." })
+}).annotate({
 	identifier: "SettingsListResult",
 	title: "settings_list result",
 	description: "Roster of distinct Vitest settings hashes the reporter has captured."
@@ -31,12 +31,11 @@ const formatSettingsListMarkdown = (data) => {
 	for (const s of data.settings) lines.push(`| ${s.hash} | ${s.capturedAt} |`);
 	return lines.join("\n");
 };
-const SettingsListAsMarkdown = Schema.transformOrFail(SettingsListResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(formatSettingsListMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "SettingsListAsMarkdown is one-way."))
-});
-const settingsList = publicProcedure.input(Schema.standardSchemaV1(Schema.Struct({}))).query(async ({ ctx }) => ctx.runtime.runPromise(Effect.gen(function* () {
+const SettingsListAsMarkdown = SettingsListResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform((data) => formatSettingsListMarkdown(data)),
+	encode: SchemaGetter.forbidden(() => "SettingsListAsMarkdown is one-way.")
+}));
+const settingsList = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({}))).query(async ({ ctx }) => ctx.runtime.runPromise(Effect.gen(function* () {
 	const settings = yield* (yield* DataReader).listSettings();
 	return {
 		count: settings.length,

package/tools/status.js

@@ -1,6 +1,6 @@
 import { publicProcedure } from "../context.js";
 import { CacheManifestEntry, DataReader } from "@vitest-agent/sdk";
-import { Effect, Option, ParseResult, Schema } from "effect";
+import { Effect, Option, Schema, SchemaGetter } from "effect";
 
 //#region src/tools/status.ts
 /**
@@ -9,17 +9,17 @@ import { Effect, Option, ParseResult, Schema } from "effect";
 * @packageDocumentation
 */
 const StatusAvailable = Schema.Struct({
-	dataAvailable: Schema.Literal(true).annotations({ description: "Discriminant — `true` when at least one project entry exists in the manifest." }),
+	dataAvailable: Schema.Literal(true).annotate({ description: "Discriminant — `true` when at least one project entry exists in the manifest." }),
 	manifestUpdatedAt: Schema.String,
-	projectFilter: Schema.optional(Schema.String).annotations({ description: "Echo of the optional `project` filter." }),
-	entries: Schema.Array(CacheManifestEntry).annotations({ description: "Per-project last-run summary rows. Filtered by `projectFilter` when set." })
-}).annotations({ identifier: "TestStatusAvailable" });
+	projectFilter: Schema.optional(Schema.String).annotate({ description: "Echo of the optional `project` filter." }),
+	entries: Schema.Array(CacheManifestEntry).annotate({ description: "Per-project last-run summary rows. Filtered by `projectFilter` when set." })
+}).annotate({ identifier: "TestStatusAvailable" });
 const StatusAbsent = Schema.Struct({
-	dataAvailable: Schema.Literal(false).annotations({ description: "Discriminant — `false` when no manifest exists or the project filter matched nothing." }),
+	dataAvailable: Schema.Literal(false).annotate({ description: "Discriminant — `false` when no manifest exists or the project filter matched nothing." }),
 	projectFilter: Schema.optional(Schema.String),
-	reason: Schema.Literal("no_manifest", "project_filter_empty")
-}).annotations({ identifier: "TestStatusAbsent" });
-const TestStatusResult = Schema.Union(StatusAvailable, StatusAbsent).annotations({
+	reason: Schema.Literals(["no_manifest", "project_filter_empty"])
+}).annotate({ identifier: "TestStatusAbsent" });
+const TestStatusResult = Schema.Union([StatusAvailable, StatusAbsent]).annotate({
 	identifier: "TestStatusResult",
 	title: "test_status result",
 	description: "Per-project last-run summary. Discriminate on `dataAvailable` for cold-start handling."
@@ -43,12 +43,11 @@ const formatTestStatusMarkdown = (data) => {
 	lines.push("", `_Cache updated: ${data.manifestUpdatedAt}_`);
 	return lines.join("\n");
 };
-const TestStatusAsMarkdown = Schema.transformOrFail(TestStatusResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(formatTestStatusMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "TestStatusAsMarkdown is one-way."))
-});
-const testStatus = publicProcedure.input(Schema.standardSchemaV1(Schema.Struct({ project: Schema.optional(Schema.String) }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
+const TestStatusAsMarkdown = TestStatusResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform((data) => formatTestStatusMarkdown(data)),
+	encode: SchemaGetter.forbidden(() => "TestStatusAsMarkdown is one-way.")
+}));
+const testStatus = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({ project: Schema.optional(Schema.String) }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
 	const manifestOpt = yield* (yield* DataReader).getManifest();
 	if (Option.isNone(manifestOpt)) return {
 		dataAvailable: false,

package/tools/tdd-artifact.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/tdd-artifact.ts
 /**
@@ -15,33 +15,49 @@ import { Effect, ParseResult, Schema } from "effect";
 *
 * @packageDocumentation
 */
-const ArtifactKindSchema = Schema.Literal("test_written", "test_failed_run", "code_written", "test_passed_run", "refactor", "test_weakened");
+const ArtifactKindSchema = Schema.Literals([
+	"test_written",
+	"test_failed_run",
+	"code_written",
+	"test_passed_run",
+	"refactor",
+	"test_weakened"
+]);
 const TddArtifactRow = Schema.Struct({
-	id: Schema.Number.annotations({
+	id: Schema.Number.annotate({
 		title: "tdd_artifacts.id",
 		description: "Pass as `citedArtifactId` to `tdd_phase_transition_request`."
 	}),
 	tddTaskId: Schema.Number,
 	phaseId: Schema.Number,
-	phaseName: Schema.Literal("spike", "red", "red.triangulate", "green", "green.fake-it", "refactor", "extended-red", "green-without-red"),
+	phaseName: Schema.Literals([
+		"spike",
+		"red",
+		"red.triangulate",
+		"green",
+		"green.fake-it",
+		"refactor",
+		"extended-red",
+		"green-without-red"
+	]),
 	artifactKind: ArtifactKindSchema,
 	behaviorId: Schema.NullOr(Schema.Number),
 	testCaseId: Schema.NullOr(Schema.Number),
 	testRunId: Schema.NullOr(Schema.Number),
 	testFirstFailureRunId: Schema.NullOr(Schema.Number),
 	recordedAt: Schema.String
-}).annotations({ identifier: "TddArtifactListRow" });
+}).annotate({ identifier: "TddArtifactListRow" });
 const ArtifactFilters = Schema.Struct({
 	artifactKind: Schema.optional(ArtifactKindSchema),
 	phaseId: Schema.optional(Schema.Number),
 	behaviorId: Schema.optional(Schema.Number)
-}).annotations({ identifier: "TddArtifactFilters" });
+}).annotate({ identifier: "TddArtifactFilters" });
 const TddArtifactListResult = Schema.Struct({
 	tddTaskId: Schema.Number,
 	filters: ArtifactFilters,
 	count: Schema.Number,
 	artifacts: Schema.Array(TddArtifactRow)
-}).annotations({
+}).annotate({
 	identifier: "TddArtifactListResult",
 	title: "tdd_artifact_list result",
 	description: "Newest-first artifact rows for a TDD task. Echoes the filters that were applied so callers can reason about what is/isn't included."
@@ -65,11 +81,10 @@ const formatTddArtifactListMarkdown = (data) => {
 	}
 	return lines.join("\n");
 };
-const TddArtifactListAsMarkdown = Schema.transformOrFail(TddArtifactListResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(formatTddArtifactListMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "TddArtifactListAsMarkdown is one-way."))
-});
+const TddArtifactListAsMarkdown = TddArtifactListResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform((data) => formatTddArtifactListMarkdown(data)),
+	encode: SchemaGetter.forbidden(() => "TddArtifactListAsMarkdown is one-way.")
+}));
 const TddArtifactListInput = Schema.Struct({
 	tddTaskId: Schema.Number,
 	artifactKind: Schema.optional(ArtifactKindSchema),
@@ -77,7 +92,7 @@ const TddArtifactListInput = Schema.Struct({
 	behaviorId: Schema.optional(Schema.Number),
 	limit: Schema.optional(Schema.Number)
 });
-const tddArtifactList = publicProcedure.input(Schema.standardSchemaV1(TddArtifactListInput)).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
+const tddArtifactList = publicProcedure.input(Schema.toStandardSchemaV1(TddArtifactListInput)).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
 	const rows = yield* (yield* DataReader).listTddArtifactsForTask({
 		tddTaskId: input.tddTaskId,
 		...input.artifactKind !== void 0 && { artifactKind: input.artifactKind },

package/tools/tdd-behavior.js

@@ -13,27 +13,29 @@ import { Effect, Match, Option, Schema } from "effect";
 * folds into the action discriminator here as `list_by_goal` /
 * `list_by_tdd_task`).
 */
-const BehaviorStatus = Schema.Literal("pending", "in_progress", "done", "abandoned");
+const BehaviorStatus = Schema.Literals([
+	"pending",
+	"in_progress",
+	"done",
+	"abandoned"
+]);
 const TddBehaviorErrorEnvelope = Schema.Struct({
-	ok: Schema.Literal(false).annotations({ description: "Discriminant — `false` when a tagged TDD error was caught." }),
-	error: Schema.Struct({
-		_tag: Schema.String.annotations({ description: "Tagged error name (e.g. BehaviorNotFoundError, GoalNotFoundError)." }),
+	ok: Schema.Literal(false).annotate({ description: "Discriminant — `false` when a tagged TDD error was caught." }),
+	error: Schema.StructWithRest(Schema.Struct({
+		_tag: Schema.String.annotate({ description: "Tagged error name (e.g. BehaviorNotFoundError, GoalNotFoundError)." }),
 		message: Schema.String,
 		remediation: Schema.optional(Schema.String)
-	}).pipe(Schema.extend(Schema.Record({
-		key: Schema.String,
-		value: Schema.Unknown
-	})))
-}).annotations({ identifier: "TddBehaviorErrorEnvelope" });
+	}), [Schema.Record(Schema.String, Schema.Unknown)])
+}).annotate({ identifier: "TddBehaviorErrorEnvelope" });
 const TddBehaviorCreateOk = Schema.Struct({
 	ok: Schema.Literal(true),
 	action: Schema.Literal("create"),
-	behavior: BehaviorRow.annotations({ description: "Newly inserted behavior row." })
+	behavior: BehaviorRow.annotate({ description: "Newly inserted behavior row." })
 });
 const TddBehaviorUpdateOk = Schema.Struct({
 	ok: Schema.Literal(true),
 	action: Schema.Literal("update"),
-	behavior: BehaviorRow.annotations({ description: "Updated behavior row." })
+	behavior: BehaviorRow.annotate({ description: "Updated behavior row." })
 });
 const TddBehaviorDeleteOk = Schema.Struct({
 	ok: Schema.Literal(true),
@@ -43,7 +45,7 @@ const TddBehaviorDeleteOk = Schema.Struct({
 const TddBehaviorGetFound = Schema.Struct({
 	action: Schema.Literal("get"),
 	found: Schema.Literal(true),
-	behavior: BehaviorDetail.annotations({ description: "Behavior with parentGoal + dependencies[]." })
+	behavior: BehaviorDetail.annotate({ description: "Behavior with parentGoal + dependencies[]." })
 });
 const TddBehaviorGetMissing = Schema.Struct({
 	action: Schema.Literal("get"),
@@ -62,7 +64,16 @@ const TddBehaviorListByTddTaskOk = Schema.Struct({
 	tddTaskId: Schema.Number,
 	behaviors: Schema.Array(BehaviorRow)
 });
-const TddBehaviorResult = Schema.Union(TddBehaviorCreateOk, TddBehaviorUpdateOk, TddBehaviorDeleteOk, TddBehaviorGetFound, TddBehaviorGetMissing, TddBehaviorListByGoalOk, TddBehaviorListByTddTaskOk, TddBehaviorErrorEnvelope).annotations({
+const TddBehaviorResult = Schema.Union([
+	TddBehaviorCreateOk,
+	TddBehaviorUpdateOk,
+	TddBehaviorDeleteOk,
+	TddBehaviorGetFound,
+	TddBehaviorGetMissing,
+	TddBehaviorListByGoalOk,
+	TddBehaviorListByTddTaskOk,
+	TddBehaviorErrorEnvelope
+]).annotate({
 	identifier: "TddBehaviorResult",
 	title: "tdd_behavior result",
 	description: "Discriminate on `action` (or `ok=false` for the tagged-error envelope)."
@@ -98,8 +109,15 @@ const ListByTddTaskVariant = Schema.Struct({
 	action: Schema.Literal("list_by_tdd_task"),
 	tddTaskId: Schema.Number
 });
-const TddBehaviorInput = Schema.Union(CreateVariant, UpdateVariant, DeleteVariant, GetVariant, ListByGoalVariant, ListByTddTaskVariant);
-const tddBehavior = idempotentProcedure.input(Schema.standardSchemaV1(TddBehaviorInput)).mutation(async ({ ctx, input }) => {
+const TddBehaviorInput = Schema.Union([
+	CreateVariant,
+	UpdateVariant,
+	DeleteVariant,
+	GetVariant,
+	ListByGoalVariant,
+	ListByTddTaskVariant
+]);
+const tddBehavior = idempotentProcedure.input(Schema.toStandardSchemaV1(TddBehaviorInput)).mutation(async ({ ctx, input }) => {
 	return ctx.runtime.runPromise(Match.value(input).pipe(Match.discriminatorsExhaustive("action")({
 		create: (variant) => catchTddErrorsAsEnvelope(Effect.gen(function* () {
 			return {

package/tools/tdd-goal.js

@@ -13,50 +13,60 @@ import { Effect, Match, Option, Schema } from "effect";
 * `{ ok: false, error: { _tag, ..., remediation } }` envelopes via
 * the shared helper.
 */
-const GoalStatus = Schema.Literal("pending", "in_progress", "done", "abandoned");
+const GoalStatus = Schema.Literals([
+	"pending",
+	"in_progress",
+	"done",
+	"abandoned"
+]);
 const TddErrorEnvelope = Schema.Struct({
-	ok: Schema.Literal(false).annotations({ description: "Discriminant — `false` when a tagged TDD error was caught." }),
-	error: Schema.Struct({
-		_tag: Schema.String.annotations({ description: "Tagged error name (e.g. GoalNotFoundError, TddTaskNotFoundError)." }),
+	ok: Schema.Literal(false).annotate({ description: "Discriminant — `false` when a tagged TDD error was caught." }),
+	error: Schema.StructWithRest(Schema.Struct({
+		_tag: Schema.String.annotate({ description: "Tagged error name (e.g. GoalNotFoundError, TddTaskNotFoundError)." }),
 		message: Schema.String,
-		remediation: Schema.optional(Schema.String).annotations({ description: "Suggested next action when known." })
-	}).pipe(Schema.extend(Schema.Record({
-		key: Schema.String,
-		value: Schema.Unknown
-	})))
-}).annotations({ identifier: "TddErrorEnvelope" });
+		remediation: Schema.optional(Schema.String).annotate({ description: "Suggested next action when known." })
+	}), [Schema.Record(Schema.String, Schema.Unknown)])
+}).annotate({ identifier: "TddErrorEnvelope" });
 const TddGoalCreateOk = Schema.Struct({
 	ok: Schema.Literal(true),
 	action: Schema.Literal("create"),
-	goal: GoalRow.annotations({ description: "Newly inserted goal row." })
-}).annotations({ identifier: "TddGoalCreateOk" });
+	goal: GoalRow.annotate({ description: "Newly inserted goal row." })
+}).annotate({ identifier: "TddGoalCreateOk" });
 const TddGoalUpdateOk = Schema.Struct({
 	ok: Schema.Literal(true),
 	action: Schema.Literal("update"),
-	goal: GoalRow.annotations({ description: "Updated goal row." })
-}).annotations({ identifier: "TddGoalUpdateOk" });
+	goal: GoalRow.annotate({ description: "Updated goal row." })
+}).annotate({ identifier: "TddGoalUpdateOk" });
 const TddGoalDeleteOk = Schema.Struct({
 	ok: Schema.Literal(true),
 	action: Schema.Literal("delete"),
 	id: Schema.Number
-}).annotations({ identifier: "TddGoalDeleteOk" });
+}).annotate({ identifier: "TddGoalDeleteOk" });
 const TddGoalGetFound = Schema.Struct({
 	action: Schema.Literal("get"),
 	found: Schema.Literal(true),
-	goal: GoalDetail.annotations({ description: "Goal with nested behaviors[]." })
-}).annotations({ identifier: "TddGoalGetFound" });
+	goal: GoalDetail.annotate({ description: "Goal with nested behaviors[]." })
+}).annotate({ identifier: "TddGoalGetFound" });
 const TddGoalGetMissing = Schema.Struct({
 	action: Schema.Literal("get"),
 	found: Schema.Literal(false),
 	id: Schema.Number
-}).annotations({ identifier: "TddGoalGetMissing" });
+}).annotate({ identifier: "TddGoalGetMissing" });
 const TddGoalListOk = Schema.Struct({
 	ok: Schema.Literal(true),
 	action: Schema.Literal("list"),
 	tddTaskId: Schema.Number,
-	goals: Schema.Array(GoalDetail).annotations({ description: "All goals for the TDD task, with their behaviors." })
-}).annotations({ identifier: "TddGoalListOk" });
-const TddGoalResult = Schema.Union(TddGoalCreateOk, TddGoalUpdateOk, TddGoalDeleteOk, TddGoalGetFound, TddGoalGetMissing, TddGoalListOk, TddErrorEnvelope).annotations({
+	goals: Schema.Array(GoalDetail).annotate({ description: "All goals for the TDD task, with their behaviors." })
+}).annotate({ identifier: "TddGoalListOk" });
+const TddGoalResult = Schema.Union([
+	TddGoalCreateOk,
+	TddGoalUpdateOk,
+	TddGoalDeleteOk,
+	TddGoalGetFound,
+	TddGoalGetMissing,
+	TddGoalListOk,
+	TddErrorEnvelope
+]).annotate({
 	identifier: "TddGoalResult",
 	title: "tdd_goal result",
 	description: "Discriminate first on `action` (or on `ok=false` for the tagged-error envelope). Get returns `found:true|false`; create/update/delete/list return `ok:true` on success."
@@ -84,8 +94,14 @@ const ListVariant = Schema.Struct({
 	action: Schema.Literal("list"),
 	tddTaskId: Schema.Number
 });
-const TddGoalInput = Schema.Union(CreateVariant, UpdateVariant, DeleteVariant, GetVariant, ListVariant);
-const tddGoal = idempotentProcedure.input(Schema.standardSchemaV1(TddGoalInput)).mutation(async ({ ctx, input }) => {
+const TddGoalInput = Schema.Union([
+	CreateVariant,
+	UpdateVariant,
+	DeleteVariant,
+	GetVariant,
+	ListVariant
+]);
+const tddGoal = idempotentProcedure.input(Schema.toStandardSchemaV1(TddGoalInput)).mutation(async ({ ctx, input }) => {
 	return ctx.runtime.runPromise(Match.value(input).pipe(Match.discriminatorsExhaustive("action")({
 		create: (variant) => catchTddErrorsAsEnvelope(Effect.gen(function* () {
 			return {

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

@@ -3,37 +3,71 @@ import { DataReader, DataStore, requiredArtifactForTransition, transitionEnforce
 import { Effect, Option, Schema } from "effect";
 
 //#region src/tools/tdd-phase-transition-request.ts
-const phaseLiteral = Schema.Literal("spike", "red", "red.triangulate", "green", "green.fake-it", "refactor", "extended-red", "green-without-red");
-const artifactKindLiteral = Schema.Literal("test_written", "test_failed_run", "code_written", "test_passed_run", "refactor", "test_weakened");
-const denialReasonLiteral = Schema.Literal("missing_artifact_evidence", "wrong_artifact_kind", "wrong_source_phase", "unknown_tdd_task", "tdd_task_already_ended", "goal_not_started", "goal_not_found", "goal_not_in_progress", "goal_not_in_tdd_task", "behavior_not_found", "behavior_not_in_goal", "refactor_without_passing_run", "evidence_not_in_phase_window", "evidence_not_for_behavior", "evidence_test_was_already_failing");
+const phaseLiteral = Schema.Literals([
+	"spike",
+	"red",
+	"red.triangulate",
+	"green",
+	"green.fake-it",
+	"refactor",
+	"extended-red",
+	"green-without-red"
+]);
+const artifactKindLiteral = Schema.Literals([
+	"test_written",
+	"test_failed_run",
+	"code_written",
+	"test_passed_run",
+	"refactor",
+	"test_weakened"
+]);
+const denialReasonLiteral = Schema.Literals([
+	"missing_artifact_evidence",
+	"wrong_artifact_kind",
+	"wrong_source_phase",
+	"unknown_tdd_task",
+	"tdd_task_already_ended",
+	"goal_not_started",
+	"goal_not_found",
+	"goal_not_in_progress",
+	"goal_not_in_tdd_task",
+	"behavior_not_found",
+	"behavior_not_in_goal",
+	"refactor_without_passing_run",
+	"evidence_not_in_phase_window",
+	"evidence_not_for_behavior",
+	"evidence_test_was_already_failing"
+]);
 const RemediationSchema = Schema.Struct({
-	suggestedTool: Schema.String.annotations({ description: "Next tool the agent should call to make progress." }),
-	suggestedArgs: Schema.Record({
-		key: Schema.String,
-		value: Schema.Unknown
-	}).annotations({ description: "Concrete arguments for `suggestedTool` that fix the underlying issue." }),
-	humanHint: Schema.String.annotations({ description: "Plain-language explanation of what to do next." })
-}).annotations({ identifier: "PhaseTransitionRemediation" });
+	suggestedTool: Schema.String.annotate({ description: "Next tool the agent should call to make progress." }),
+	suggestedArgs: Schema.Record(Schema.String, Schema.Unknown).annotate({ description: "Concrete arguments for `suggestedTool` that fix the underlying issue." }),
+	humanHint: Schema.String.annotate({ description: "Plain-language explanation of what to do next." })
+}).annotate({ identifier: "PhaseTransitionRemediation" });
 const PhaseTransitionAccepted = Schema.Struct({
-	accepted: Schema.Literal(true).annotations({ description: "Discriminant — `true` when the transition was granted." }),
-	phase: phaseLiteral.annotations({ description: "Phase the session is now in (echo of `requestedPhase`)." }),
-	newPhaseId: Schema.Number.annotations({ description: "`tdd_phases.id` of the freshly opened row." }),
-	previousPhaseId: Schema.NullOr(Schema.Number).annotations({ description: "`tdd_phases.id` of the phase that was closed (`null` for the first transition)." }),
-	citedArtifactId: Schema.optional(Schema.Number).annotations({ description: "Resolved `tdd_artifacts.id` actually used. Absent only for transitions that need no artifact (e.g. spike→red)." }),
-	citedArtifactSource: Schema.optional(Schema.Literal("explicit-id", "explicit-kind", "transition-derived", "none")).annotations({ description: "Where `citedArtifactId` came from: `explicit-id` (caller passed it), `explicit-kind` (resolved from caller's `citedArtifactKind`), `transition-derived` (resolved from the transition's required-evidence rule), or `none` (no artifact needed)." })
-}).annotations({ identifier: "PhaseTransitionAccepted" });
+	accepted: Schema.Literal(true).annotate({ description: "Discriminant — `true` when the transition was granted." }),
+	phase: phaseLiteral.annotate({ description: "Phase the session is now in (echo of `requestedPhase`)." }),
+	newPhaseId: Schema.Number.annotate({ description: "`tdd_phases.id` of the freshly opened row." }),
+	previousPhaseId: Schema.NullOr(Schema.Number).annotate({ description: "`tdd_phases.id` of the phase that was closed (`null` for the first transition)." }),
+	citedArtifactId: Schema.optional(Schema.Number).annotate({ description: "Resolved `tdd_artifacts.id` actually used. Absent only for transitions that need no artifact (e.g. spike→red)." }),
+	citedArtifactSource: Schema.optional(Schema.Literals([
+		"explicit-id",
+		"explicit-kind",
+		"transition-derived",
+		"none"
+	])).annotate({ description: "Where `citedArtifactId` came from: `explicit-id` (caller passed it), `explicit-kind` (resolved from caller's `citedArtifactKind`), `transition-derived` (resolved from the transition's required-evidence rule), or `none` (no artifact needed)." })
+}).annotate({ identifier: "PhaseTransitionAccepted" });
 const PhaseTransitionDenied = Schema.Struct({
-	accepted: Schema.Literal(false).annotations({ description: "Discriminant — `false` when the transition was refused." }),
-	phase: phaseLiteral.annotations({ description: "Phase the session remains in (the current phase, unchanged)." }),
-	denialReason: denialReasonLiteral.annotations({ description: "Categorical refusal reason; see `remediation` for the suggested fix." }),
+	accepted: Schema.Literal(false).annotate({ description: "Discriminant — `false` when the transition was refused." }),
+	phase: phaseLiteral.annotate({ description: "Phase the session remains in (the current phase, unchanged)." }),
+	denialReason: denialReasonLiteral.annotate({ description: "Categorical refusal reason; see `remediation` for the suggested fix." }),
 	remediation: RemediationSchema
-}).annotations({ identifier: "PhaseTransitionDenied" });
-const PhaseTransitionResult = Schema.Union(PhaseTransitionAccepted, PhaseTransitionDenied).annotations({
+}).annotate({ identifier: "PhaseTransitionDenied" });
+const PhaseTransitionResult = Schema.Union([PhaseTransitionAccepted, PhaseTransitionDenied]).annotate({
 	identifier: "PhaseTransitionResult",
 	title: "tdd_phase_transition_request result",
 	description: "Discriminate on `accepted`. Acceptance carries the new phaseId; denial carries a typed reason and a remediation pointer."
 });
-const tddPhaseTransitionRequest = publicProcedure.input(Schema.standardSchemaV1(Schema.Struct({
+const tddPhaseTransitionRequest = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({
 	tddTaskId: Schema.Number,
 	goalId: Schema.Number,
 	requestedPhase: phaseLiteral,
@@ -190,13 +224,13 @@ const tddPhaseTransitionRequest = publicProcedure.input(Schema.standardSchemaV1(
 			...input.behaviorId !== void 0 && { behaviorId: input.behaviorId },
 			...input.reason !== void 0 && { transitionReason: input.reason }
 		});
-		if (input.behaviorId !== void 0) yield* Effect.ignoreLogged(Effect.gen(function* () {
+		if (input.behaviorId !== void 0) yield* Effect.gen(function* () {
 			const behOpt = yield* reader.getBehaviorById(input.behaviorId);
 			if (Option.isSome(behOpt) && behOpt.value.status === "pending") yield* store.updateBehavior({
 				id: input.behaviorId,
 				status: "in_progress"
 			});
-		}));
+		}).pipe(Effect.catchCause((cause) => Effect.logDebug("behavior auto-promotion failed", cause)));
 		return {
 			accepted: true,
 			phase: result.phase,