@vitest-agent/mcp 3.0.4 → 4.0.0

package/tools/tdd-artifact.js

@@ -1,20 +1,9 @@
-import { publicProcedure } from "../context.js";
+import { RenderText } from "../annotations.js";
 import { Effect, Schema, SchemaGetter } from "effect";
-import { DataReader } from "@vitest-agent/sdk";
+import { DataReader } from "@vitest-agent/engine";
+import { Tool } from "effect/unstable/ai";
 
 //#region src/tools/tdd-artifact.ts
-/**
-* `tdd_artifact_list` MCP tool — Schema-driven implementation.
-*
-* Returns the artifacts recorded for a TDD task, ordered with the
-* most recent first. The structuredContent payload carries
-* tddTaskId, the applied filters, the count, and the artifact
-* rows so the orchestrator can extract artifact ids without parsing
-* markdown. The legacy `format` input was dropped because
-* structuredContent supersedes it.
-*
-* @packageDocumentation
-*/
 const ArtifactKindSchema = Schema.Literals([
 	"test_written",
 	"test_failed_run",
@@ -53,6 +42,11 @@ const ArtifactFilters = Schema.Struct({
 	phaseId: Schema.optional(Schema.Number),
 	behaviorId: Schema.optional(Schema.Number)
 }).annotate({ identifier: "TddArtifactFilters" });
+/**
+* The `tdd_artifact_list` tool's success payload.
+*
+* @public
+*/
 const TddArtifactListResult = Schema.Struct({
 	tddTaskId: Schema.Number,
 	filters: ArtifactFilters,
@@ -86,14 +80,24 @@ const TddArtifactListAsMarkdown = TddArtifactListResult.pipe(Schema.decodeTo(Sch
 	decode: SchemaGetter.transform((data) => formatTddArtifactListMarkdown(data)),
 	encode: SchemaGetter.forbidden(() => "TddArtifactListAsMarkdown is one-way.")
 }));
+/**
+* The `tdd_artifact_list` tool's parameters.
+*
+* @public
+*/
 const TddArtifactListInput = Schema.Struct({
-	tddTaskId: Schema.Number,
-	artifactKind: Schema.optional(ArtifactKindSchema),
-	phaseId: Schema.optional(Schema.Number),
-	behaviorId: Schema.optional(Schema.Number),
-	limit: Schema.optional(Schema.Number)
+	tddTaskId: Schema.Finite.annotate({ description: "tdd_tasks.id" }),
+	artifactKind: Schema.optionalKey(ArtifactKindSchema).annotate({ description: "Restrict to one artifact kind" }),
+	phaseId: Schema.optionalKey(Schema.Finite).annotate({ description: "Restrict to artifacts recorded in one phase" }),
+	behaviorId: Schema.optionalKey(Schema.Finite).annotate({ description: "Restrict to artifacts recorded in phases bound to one behavior" }),
+	limit: Schema.optionalKey(Schema.Finite).annotate({ description: "Max rows (default 50)" })
 });
-const tddArtifactList = publicProcedure.input(Schema.toStandardSchemaV1(TddArtifactListInput)).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
+/**
+* Handler for {@link tddArtifactListTool}.
+*
+* @public
+*/
+const handleTddArtifactList = (input) => Effect.gen(function* () {
 	const rows = yield* (yield* DataReader).listTddArtifactsForTask({
 		tddTaskId: input.tddTaskId,
 		...input.artifactKind !== void 0 && { artifactKind: input.artifactKind },
@@ -111,7 +115,18 @@ const tddArtifactList = publicProcedure.input(Schema.toStandardSchemaV1(TddArtif
 		count: rows.length,
 		artifacts: rows
 	};
-})));
+}).pipe(Effect.orDie);
+/**
+* The Effect-native `tdd_artifact_list` tool.
+*
+* @public
+*/
+const tddArtifactListTool = Tool.make("tdd_artifact_list", {
+	description: "Use when you need the artifact id to cite in tdd_phase_transition_request without querying SQLite directly. Lists TDD artifacts (test_written, test_failed_run, code_written, test_passed_run, refactor, test_weakened) for a tdd_task, newest first. Filters: artifactKind, phaseId, behaviorId, limit (default 50).",
+	parameters: TddArtifactListInput,
+	success: TddArtifactListResult,
+	dependencies: [DataReader]
+}).annotate(Tool.Title, "TDD artifact list").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => formatTddArtifactListMarkdown(encoded));
 
 //#endregion
-export { TddArtifactListAsMarkdown, TddArtifactListResult, formatTddArtifactListMarkdown, tddArtifactList };
+export { TddArtifactListInput, TddArtifactListResult, formatTddArtifactListMarkdown, handleTddArtifactList, tddArtifactListTool };

package/tools/tdd-behavior.js

@@ -1,7 +1,9 @@
-import { idempotentProcedure } from "../middleware/idempotency.js";
+import { IdempotentReplayMarker } from "../utils/replay-marker.js";
 import { catchTddErrorsAsEnvelope } from "./_tdd-error-envelope.js";
 import { Effect, Match, Option, Schema } from "effect";
-import { BehaviorDetail, BehaviorRow, DataReader, DataStore } from "@vitest-agent/sdk";
+import { DataReader, DataStore } from "@vitest-agent/engine";
+import { Tool } from "effect/unstable/ai";
+import { BehaviorDetail, BehaviorRow } from "@vitest-agent/sdk";
 
 //#region src/tools/tdd-behavior.ts
 /**
@@ -23,14 +25,18 @@ const TddBehaviorErrorEnvelope = Schema.Struct({
 	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)
+		remediation: Schema.Struct({
+			suggestedTool: Schema.String,
+			suggestedArgs: Schema.Record(Schema.String, Schema.Unknown),
+			humanHint: Schema.String
+		}).annotate({ description: "Suggested next action: the tool to call, its arguments, and a plain-language hint." })
 	}), [Schema.Record(Schema.String, Schema.Unknown)])
 }).annotate({ identifier: "TddBehaviorErrorEnvelope" });
 const TddBehaviorCreateOk = Schema.Struct({
 	ok: Schema.Literal(true),
 	action: Schema.Literal("create"),
-	behavior: BehaviorRow.annotate({ description: "Newly inserted behavior row." })
+	behavior: BehaviorRow.annotate({ description: "Newly inserted behavior row." }),
+	...IdempotentReplayMarker
 });
 const TddBehaviorUpdateOk = Schema.Struct({
 	ok: Schema.Literal(true),
@@ -79,36 +85,41 @@ const TddBehaviorResult = Schema.Union([
 	description: "Discriminate on `action` (or `ok=false` for the tagged-error envelope)."
 });
 const CreateVariant = Schema.Struct({
-	action: Schema.Literal("create"),
-	goalId: Schema.Number,
+	action: Schema.Literal("create").annotate({ description: "CRUD discriminator" }),
+	goalId: Schema.Finite,
 	behavior: Schema.String,
-	suggestedTestName: Schema.optional(Schema.String),
-	dependsOnBehaviorIds: Schema.optional(Schema.Array(Schema.Number))
+	suggestedTestName: Schema.optionalKey(Schema.String),
+	dependsOnBehaviorIds: Schema.optionalKey(Schema.Array(Schema.Finite))
 });
 const UpdateVariant = Schema.Struct({
-	action: Schema.Literal("update"),
-	id: Schema.Number,
-	behavior: Schema.optional(Schema.String),
-	suggestedTestName: Schema.optional(Schema.NullOr(Schema.String)),
-	status: Schema.optional(BehaviorStatus),
-	dependsOnBehaviorIds: Schema.optional(Schema.Array(Schema.Number))
+	action: Schema.Literal("update").annotate({ description: "CRUD discriminator" }),
+	id: Schema.Finite,
+	behavior: Schema.optionalKey(Schema.String),
+	suggestedTestName: Schema.optionalKey(Schema.NullOr(Schema.String)),
+	status: Schema.optionalKey(BehaviorStatus),
+	dependsOnBehaviorIds: Schema.optionalKey(Schema.Array(Schema.Finite))
 });
 const DeleteVariant = Schema.Struct({
-	action: Schema.Literal("delete"),
-	id: Schema.Number
+	action: Schema.Literal("delete").annotate({ description: "CRUD discriminator" }),
+	id: Schema.Finite
 });
 const GetVariant = Schema.Struct({
-	action: Schema.Literal("get"),
-	id: Schema.Number
+	action: Schema.Literal("get").annotate({ description: "CRUD discriminator" }),
+	id: Schema.Finite
 });
 const ListByGoalVariant = Schema.Struct({
-	action: Schema.Literal("list_by_goal"),
-	goalId: Schema.Number
+	action: Schema.Literal("list_by_goal").annotate({ description: "CRUD discriminator" }),
+	goalId: Schema.Finite
 });
 const ListByTddTaskVariant = Schema.Struct({
-	action: Schema.Literal("list_by_tdd_task"),
-	tddTaskId: Schema.Number
+	action: Schema.Literal("list_by_tdd_task").annotate({ description: "CRUD discriminator" }),
+	tddTaskId: Schema.Finite
 });
+/**
+* The `tdd_behavior` tool's parameters — a union discriminated on `action`.
+*
+* @public
+*/
 const TddBehaviorInput = Schema.Union([
 	CreateVariant,
 	UpdateVariant,
@@ -118,92 +129,93 @@ const TddBehaviorInput = Schema.Union([
 	ListByTddTaskVariant
 ]);
 /**
-* Single source of truth for the `tdd_behavior` tool's `action`
-* discriminant, consumed by `server.ts`'s served `z.enum(...)` so the
-* MCP-SDK-side registration cannot drift from this tRPC input union
-* (issue #335).
+* Handler for {@link tddBehaviorTool}. The five tagged TDD errors come
+* back as the `{ ok: false, error }` envelope; anything else is a defect.
+*
+* @public
 */
-const TDD_BEHAVIOR_ACTIONS = [
-	"create",
-	"update",
-	"delete",
-	"get",
-	"list_by_goal",
-	"list_by_tdd_task"
-];
-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 {
-				ok: true,
-				action: "create",
-				behavior: yield* (yield* DataStore).createBehavior({
-					goalId: variant.goalId,
-					behavior: variant.behavior,
-					...variant.suggestedTestName !== void 0 && { suggestedTestName: variant.suggestedTestName },
-					...variant.dependsOnBehaviorIds !== void 0 && { dependsOnBehaviorIds: variant.dependsOnBehaviorIds }
-				})
-			};
-		})),
-		update: (variant) => catchTddErrorsAsEnvelope(Effect.gen(function* () {
-			return {
-				ok: true,
-				action: "update",
-				behavior: yield* (yield* DataStore).updateBehavior({
-					id: variant.id,
-					...variant.behavior !== void 0 && { behavior: variant.behavior },
-					...variant.suggestedTestName !== void 0 && { suggestedTestName: variant.suggestedTestName },
-					...variant.status !== void 0 && { status: variant.status },
-					...variant.dependsOnBehaviorIds !== void 0 && { dependsOnBehaviorIds: variant.dependsOnBehaviorIds }
-				})
-			};
-		})),
-		delete: (variant) => catchTddErrorsAsEnvelope(Effect.gen(function* () {
-			yield* (yield* DataStore).deleteBehavior(variant.id);
-			return {
-				ok: true,
-				action: "delete",
-				id: variant.id
-			};
-		})),
-		get: (variant) => Effect.gen(function* () {
-			const opt = yield* (yield* DataReader).getBehaviorById(variant.id);
-			return Option.isNone(opt) ? {
-				action: "get",
-				found: false,
-				id: variant.id
-			} : {
-				action: "get",
-				found: true,
-				behavior: opt.value
-			};
-		}),
-		list_by_goal: (variant) => catchTddErrorsAsEnvelope(Effect.gen(function* () {
-			const store = yield* DataStore;
-			const reader = yield* DataReader;
-			yield* store.listBehaviorsByGoal(variant.goalId);
-			const behaviors = yield* reader.getBehaviorsByGoal(variant.goalId);
-			return {
-				ok: true,
-				action: "list_by_goal",
+const handleTddBehavior = (input) => Match.value(input).pipe(Match.discriminatorsExhaustive("action")({
+	create: (variant) => catchTddErrorsAsEnvelope(Effect.gen(function* () {
+		return {
+			ok: true,
+			action: "create",
+			behavior: yield* (yield* DataStore).createBehavior({
 				goalId: variant.goalId,
-				behaviors
-			};
-		})),
-		list_by_tdd_task: (variant) => catchTddErrorsAsEnvelope(Effect.gen(function* () {
-			const store = yield* DataStore;
-			const reader = yield* DataReader;
-			yield* store.listBehaviorsByTddTask(variant.tddTaskId);
-			const behaviors = yield* reader.getBehaviorsByTddTask(variant.tddTaskId);
-			return {
-				ok: true,
-				action: "list_by_tdd_task",
-				tddTaskId: variant.tddTaskId,
-				behaviors
-			};
-		}))
-	})));
-});
+				behavior: variant.behavior,
+				...variant.suggestedTestName !== void 0 && { suggestedTestName: variant.suggestedTestName },
+				...variant.dependsOnBehaviorIds !== void 0 && { dependsOnBehaviorIds: variant.dependsOnBehaviorIds }
+			})
+		};
+	})),
+	update: (variant) => catchTddErrorsAsEnvelope(Effect.gen(function* () {
+		return {
+			ok: true,
+			action: "update",
+			behavior: yield* (yield* DataStore).updateBehavior({
+				id: variant.id,
+				...variant.behavior !== void 0 && { behavior: variant.behavior },
+				...variant.suggestedTestName !== void 0 && { suggestedTestName: variant.suggestedTestName },
+				...variant.status !== void 0 && { status: variant.status },
+				...variant.dependsOnBehaviorIds !== void 0 && { dependsOnBehaviorIds: variant.dependsOnBehaviorIds }
+			})
+		};
+	})),
+	delete: (variant) => catchTddErrorsAsEnvelope(Effect.gen(function* () {
+		yield* (yield* DataStore).deleteBehavior(variant.id);
+		return {
+			ok: true,
+			action: "delete",
+			id: variant.id
+		};
+	})),
+	get: (variant) => Effect.gen(function* () {
+		const opt = yield* (yield* DataReader).getBehaviorById(variant.id);
+		return Option.isNone(opt) ? {
+			action: "get",
+			found: false,
+			id: variant.id
+		} : {
+			action: "get",
+			found: true,
+			behavior: opt.value
+		};
+	}),
+	list_by_goal: (variant) => catchTddErrorsAsEnvelope(Effect.gen(function* () {
+		const store = yield* DataStore;
+		const reader = yield* DataReader;
+		yield* store.listBehaviorsByGoal(variant.goalId);
+		const behaviors = yield* reader.getBehaviorsByGoal(variant.goalId);
+		return {
+			ok: true,
+			action: "list_by_goal",
+			goalId: variant.goalId,
+			behaviors
+		};
+	})),
+	list_by_tdd_task: (variant) => catchTddErrorsAsEnvelope(Effect.gen(function* () {
+		const store = yield* DataStore;
+		const reader = yield* DataReader;
+		yield* store.listBehaviorsByTddTask(variant.tddTaskId);
+		const behaviors = yield* reader.getBehaviorsByTddTask(variant.tddTaskId);
+		return {
+			ok: true,
+			action: "list_by_tdd_task",
+			tddTaskId: variant.tddTaskId,
+			behaviors
+		};
+	}))
+})).pipe(Effect.orDie);
+/**
+* The Effect-native `tdd_behavior` tool.
+*
+* @public
+*/
+const tddBehaviorTool = Tool.make("tdd_behavior", {
+	description: "Use to manage TDD behaviors, with a CRUD action discriminator: action='create' (goalId, behavior, suggestedTestName?, dependsOnBehaviorIds?) is idempotent on (goalId, behavior); action='update' (id, ...patch) edits; action='delete' (id) hard-deletes; action='get' (id) reads; action='list_by_goal' (goalId) lists one goal's behaviors; action='list_by_tdd_task' (tddTaskId) lists across all goals.",
+	parameters: TddBehaviorInput,
+	success: TddBehaviorResult,
+	dependencies: [DataReader, DataStore]
+}).annotate(Tool.Title, "TDD behavior").annotate(Tool.Readonly, false).annotate(Tool.Destructive, true).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, false);
 
 //#endregion
-export { TDD_BEHAVIOR_ACTIONS, TddBehaviorResult, tddBehavior };
+export { TddBehaviorInput, TddBehaviorResult, handleTddBehavior, tddBehaviorTool };

package/tools/tdd-goal.js

@@ -1,7 +1,9 @@
-import { idempotentProcedure } from "../middleware/idempotency.js";
+import { IdempotentReplayMarker } from "../utils/replay-marker.js";
 import { catchTddErrorsAsEnvelope } from "./_tdd-error-envelope.js";
 import { Effect, Match, Option, Schema } from "effect";
-import { DataReader, DataStore, GoalDetail, GoalRow } from "@vitest-agent/sdk";
+import { DataReader, DataStore } from "@vitest-agent/engine";
+import { Tool } from "effect/unstable/ai";
+import { GoalDetail, GoalRow } from "@vitest-agent/sdk";
 
 //#region src/tools/tdd-goal.ts
 /**
@@ -23,14 +25,18 @@ const TddErrorEnvelope = Schema.Struct({
 	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).annotate({ description: "Suggested next action when known." })
+		remediation: Schema.Struct({
+			suggestedTool: Schema.String,
+			suggestedArgs: Schema.Record(Schema.String, Schema.Unknown),
+			humanHint: Schema.String
+		}).annotate({ description: "Suggested next action: the tool to call, its arguments, and a plain-language hint." })
 	}), [Schema.Record(Schema.String, Schema.Unknown)])
 }).annotate({ identifier: "TddErrorEnvelope" });
 const TddGoalCreateOk = Schema.Struct({
 	ok: Schema.Literal(true),
 	action: Schema.Literal("create"),
-	goal: GoalRow.annotate({ description: "Newly inserted goal row." })
+	goal: GoalRow.annotate({ description: "Newly inserted goal row." }),
+	...IdempotentReplayMarker
 }).annotate({ identifier: "TddGoalCreateOk" });
 const TddGoalUpdateOk = Schema.Struct({
 	ok: Schema.Literal(true),
@@ -72,28 +78,33 @@ const TddGoalResult = Schema.Union([
 	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."
 });
 const CreateVariant = Schema.Struct({
-	action: Schema.Literal("create"),
-	tddTaskId: Schema.Number,
+	action: Schema.Literal("create").annotate({ description: "CRUD discriminator" }),
+	tddTaskId: Schema.Finite.annotate({ description: "create/list: tdd task id" }),
 	goal: Schema.String
 });
 const UpdateVariant = Schema.Struct({
-	action: Schema.Literal("update"),
-	id: Schema.Number,
-	goal: Schema.optional(Schema.String),
-	status: Schema.optional(GoalStatus)
+	action: Schema.Literal("update").annotate({ description: "CRUD discriminator" }),
+	id: Schema.Finite.annotate({ description: "update/delete/get: goal id" }),
+	goal: Schema.optionalKey(Schema.String),
+	status: Schema.optionalKey(GoalStatus)
 });
 const DeleteVariant = Schema.Struct({
-	action: Schema.Literal("delete"),
-	id: Schema.Number
+	action: Schema.Literal("delete").annotate({ description: "CRUD discriminator" }),
+	id: Schema.Finite.annotate({ description: "update/delete/get: goal id" })
 });
 const GetVariant = Schema.Struct({
-	action: Schema.Literal("get"),
-	id: Schema.Number
+	action: Schema.Literal("get").annotate({ description: "CRUD discriminator" }),
+	id: Schema.Finite.annotate({ description: "update/delete/get: goal id" })
 });
 const ListVariant = Schema.Struct({
-	action: Schema.Literal("list"),
-	tddTaskId: Schema.Number
+	action: Schema.Literal("list").annotate({ description: "CRUD discriminator" }),
+	tddTaskId: Schema.Finite.annotate({ description: "create/list: tdd task id" })
 });
+/**
+* The `tdd_goal` tool's parameters — a union discriminated on `action`.
+*
+* @public
+*/
 const TddGoalInput = Schema.Union([
 	CreateVariant,
 	UpdateVariant,
@@ -102,75 +113,77 @@ const TddGoalInput = Schema.Union([
 	ListVariant
 ]);
 /**
-* Single source of truth for the `tdd_goal` tool's `action`
-* discriminant, consumed by `server.ts`'s served `z.enum(...)` so the
-* MCP-SDK-side registration cannot drift from this tRPC input union
-* (issue #335).
+* Handler for {@link tddGoalTool}. The five tagged TDD errors come back as
+* the `{ ok: false, error }` envelope; anything else is a defect.
+*
+* @public
 */
-const TDD_GOAL_ACTIONS = [
-	"create",
-	"update",
-	"delete",
-	"get",
-	"list"
-];
-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 {
-				ok: true,
-				action: "create",
-				goal: yield* (yield* DataStore).createGoal({
-					tddTaskId: variant.tddTaskId,
-					goal: variant.goal
-				})
-			};
-		})),
-		update: (variant) => catchTddErrorsAsEnvelope(Effect.gen(function* () {
-			return {
-				ok: true,
-				action: "update",
-				goal: yield* (yield* DataStore).updateGoal({
-					id: variant.id,
-					...variant.goal !== void 0 && { goal: variant.goal },
-					...variant.status !== void 0 && { status: variant.status }
-				})
-			};
-		})),
-		delete: (variant) => catchTddErrorsAsEnvelope(Effect.gen(function* () {
-			yield* (yield* DataStore).deleteGoal(variant.id);
-			return {
-				ok: true,
-				action: "delete",
-				id: variant.id
-			};
-		})),
-		get: (variant) => Effect.gen(function* () {
-			const opt = yield* (yield* DataReader).getGoalById(variant.id);
-			return Option.isNone(opt) ? {
-				action: "get",
-				found: false,
-				id: variant.id
-			} : {
-				action: "get",
-				found: true,
-				goal: opt.value
-			};
-		}),
-		list: (variant) => catchTddErrorsAsEnvelope(Effect.gen(function* () {
-			const store = yield* DataStore;
-			const reader = yield* DataReader;
-			yield* store.listGoalsByTddTask(variant.tddTaskId);
-			const goals = yield* reader.getGoalsByTddTask(variant.tddTaskId);
-			return {
-				ok: true,
-				action: "list",
+const handleTddGoal = (input) => Match.value(input).pipe(Match.discriminatorsExhaustive("action")({
+	create: (variant) => catchTddErrorsAsEnvelope(Effect.gen(function* () {
+		return {
+			ok: true,
+			action: "create",
+			goal: yield* (yield* DataStore).createGoal({
 				tddTaskId: variant.tddTaskId,
-				goals
-			};
-		}))
-	})));
-});
+				goal: variant.goal
+			})
+		};
+	})),
+	update: (variant) => catchTddErrorsAsEnvelope(Effect.gen(function* () {
+		return {
+			ok: true,
+			action: "update",
+			goal: yield* (yield* DataStore).updateGoal({
+				id: variant.id,
+				...variant.goal !== void 0 && { goal: variant.goal },
+				...variant.status !== void 0 && { status: variant.status }
+			})
+		};
+	})),
+	delete: (variant) => catchTddErrorsAsEnvelope(Effect.gen(function* () {
+		yield* (yield* DataStore).deleteGoal(variant.id);
+		return {
+			ok: true,
+			action: "delete",
+			id: variant.id
+		};
+	})),
+	get: (variant) => Effect.gen(function* () {
+		const opt = yield* (yield* DataReader).getGoalById(variant.id);
+		return Option.isNone(opt) ? {
+			action: "get",
+			found: false,
+			id: variant.id
+		} : {
+			action: "get",
+			found: true,
+			goal: opt.value
+		};
+	}),
+	list: (variant) => catchTddErrorsAsEnvelope(Effect.gen(function* () {
+		const store = yield* DataStore;
+		const reader = yield* DataReader;
+		yield* store.listGoalsByTddTask(variant.tddTaskId);
+		const goals = yield* reader.getGoalsByTddTask(variant.tddTaskId);
+		return {
+			ok: true,
+			action: "list",
+			tddTaskId: variant.tddTaskId,
+			goals
+		};
+	}))
+})).pipe(Effect.orDie);
+/**
+* The Effect-native `tdd_goal` tool.
+*
+* @public
+*/
+const tddGoalTool = Tool.make("tdd_goal", {
+	description: "Use to manage TDD goals, with a CRUD action discriminator: action='create' (tddTaskId, goal) is idempotent on (tddTaskId, goal); action='update' (id, goal?, status?) edits text and/or lifecycle status; action='delete' (id) hard-deletes (prefer status:'abandoned'); action='get' (id) reads with nested behaviors; action='list' (tddTaskId) returns all goals for a TDD task.",
+	parameters: TddGoalInput,
+	success: TddGoalResult,
+	dependencies: [DataReader, DataStore]
+}).annotate(Tool.Title, "TDD goal").annotate(Tool.Readonly, false).annotate(Tool.Destructive, true).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, false);
 
 //#endregion
-export { TDD_GOAL_ACTIONS, TddGoalResult, tddGoal };
+export { TddGoalInput, TddGoalResult, handleTddGoal, tddGoalTool };