@vitest-agent/mcp 3.0.4 → 4.0.0

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

@@ -1,6 +1,8 @@
-import { publicProcedure } from "../context.js";
+import { RenderText } from "../annotations.js";
 import { Effect, Option, Schema } from "effect";
-import { DataReader, DataStore, requiredArtifactForTransition, transitionEnforcesBehaviorMatch, validatePhaseTransition } from "@vitest-agent/sdk";
+import { DataReader, DataStore } from "@vitest-agent/engine";
+import { Tool } from "effect/unstable/ai";
+import { requiredArtifactForTransition, transitionEnforcesBehaviorMatch, validatePhaseTransition } from "@vitest-agent/sdk";
 
 //#region src/tools/tdd-phase-transition-request.ts
 /**
@@ -68,198 +70,231 @@ const PhaseTransitionDenied = Schema.Struct({
 	denialReason: denialReasonLiteral.annotate({ description: "Categorical refusal reason; see `remediation` for the suggested fix." }),
 	remediation: RemediationSchema
 }).annotate({ identifier: "PhaseTransitionDenied" });
+/**
+* The `tdd_phase_transition_request` tool's success payload.
+*
+* @public
+*/
 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.toStandardSchemaV1(Schema.Struct({
-	tddTaskId: Schema.Number,
-	goalId: Schema.Number,
-	requestedPhase: phaseLiteral,
-	citedArtifactId: Schema.optional(Schema.Number),
-	citedArtifactKind: Schema.optional(artifactKindLiteral),
-	behaviorId: Schema.optional(Schema.Number),
-	reason: Schema.optional(Schema.String)
-}))).mutation(async ({ ctx, input }) => {
-	return ctx.runtime.runPromise(Effect.gen(function* () {
-		const reader = yield* DataReader;
-		const store = yield* DataStore;
-		const currentOpt = yield* reader.getCurrentTddPhase(input.tddTaskId);
-		const currentPhase = Option.isSome(currentOpt) ? currentOpt.value.phase : "spike";
-		const phaseStartedAt = Option.isSome(currentOpt) ? currentOpt.value.startedAt : (/* @__PURE__ */ new Date()).toISOString();
-		const currentPhaseId = Option.isSome(currentOpt) ? currentOpt.value.id : null;
-		const goalOpt = yield* reader.getGoalById(input.goalId);
-		if (Option.isNone(goalOpt)) return {
-			accepted: false,
-			phase: currentPhase,
-			denialReason: "goal_not_found",
-			remediation: {
-				suggestedTool: "tdd_goal",
-				suggestedArgs: {
-					action: "list",
-					tddTaskId: input.tddTaskId
-				},
-				humanHint: `No tdd_session_goals row with id=${input.goalId}. Call tdd_goal({ action: "list" }) to find the correct goal id.`
-			}
-		};
-		if (goalOpt.value.sessionId !== input.tddTaskId) return {
+/**
+* The `tdd_phase_transition_request` tool's parameters.
+*
+* `citedArtifactId` is optional in 2.0+. When omitted, the tool resolves
+* the most recent matching artifact for this session, where "matching" is
+* either the explicit `citedArtifactKind` value, or the kind required by
+* the transition (per `requiredArtifactForTransition`), or "no artifact
+* needed" for transitions like `spike→red` where the validator's
+* `requiredArtifactForTransition` returns null. The accepted response
+* carries `citedArtifactId` so the caller can see which row was used.
+*
+* @public
+*/
+const PhaseTransitionInput = Schema.Struct({
+	tddTaskId: Schema.Finite.annotate({ description: "tdd_tasks.id" }),
+	goalId: Schema.Finite.annotate({ description: "tdd_session_goals.id (required; goal must be in_progress)" }),
+	requestedPhase: phaseLiteral.annotate({ description: "Phase to transition to" }),
+	citedArtifactId: Schema.optionalKey(Schema.Finite).annotate({ description: "tdd_artifacts.id supplying the evidence. Optional — auto-resolved when omitted." }),
+	citedArtifactKind: Schema.optionalKey(artifactKindLiteral).annotate({ description: "Kind to look up when citedArtifactId is omitted (defaults to the kind required by the transition)." }),
+	behaviorId: Schema.optionalKey(Schema.Finite).annotate({ description: "tdd_session_behaviors.id when transitioning a specific behavior (must belong to goalId)" }),
+	reason: Schema.optionalKey(Schema.String).annotate({ description: "Free-text reason for the transition" })
+});
+/**
+* Handler for {@link tddPhaseTransitionRequestTool}.
+*
+* @public
+*/
+const handlePhaseTransitionRequest = (input) => Effect.gen(function* () {
+	const reader = yield* DataReader;
+	const store = yield* DataStore;
+	const currentOpt = yield* reader.getCurrentTddPhase(input.tddTaskId);
+	const currentPhase = Option.isSome(currentOpt) ? currentOpt.value.phase : "spike";
+	const phaseStartedAt = Option.isSome(currentOpt) ? currentOpt.value.startedAt : (/* @__PURE__ */ new Date()).toISOString();
+	const currentPhaseId = Option.isSome(currentOpt) ? currentOpt.value.id : null;
+	const goalOpt = yield* reader.getGoalById(input.goalId);
+	if (Option.isNone(goalOpt)) return {
+		accepted: false,
+		phase: currentPhase,
+		denialReason: "goal_not_found",
+		remediation: {
+			suggestedTool: "tdd_goal",
+			suggestedArgs: {
+				action: "list",
+				tddTaskId: input.tddTaskId
+			},
+			humanHint: `No tdd_session_goals row with id=${input.goalId}. Call tdd_goal({ action: "list" }) to find the correct goal id.`
+		}
+	};
+	if (goalOpt.value.sessionId !== input.tddTaskId) return {
+		accepted: false,
+		phase: currentPhase,
+		denialReason: "goal_not_in_tdd_task",
+		remediation: {
+			suggestedTool: "tdd_goal",
+			suggestedArgs: {
+				action: "list",
+				tddTaskId: input.tddTaskId
+			},
+			humanHint: `Goal id=${input.goalId} belongs to TDD task ${goalOpt.value.sessionId}, not the requested tddTaskId=${input.tddTaskId}. Pass the tddTaskId of the goal's parent task, or pick a goal that belongs to the active task.`
+		}
+	};
+	if (goalOpt.value.status !== "in_progress") return {
+		accepted: false,
+		phase: currentPhase,
+		denialReason: "goal_not_in_progress",
+		remediation: {
+			suggestedTool: "tdd_goal_update",
+			suggestedArgs: {
+				id: input.goalId,
+				status: "in_progress"
+			},
+			humanHint: `Goal id=${input.goalId} has status '${goalOpt.value.status}'. Phase transitions require the goal to be in_progress. Call tdd_goal_update({status:'in_progress'}) before requesting transitions.`
+		}
+	};
+	if (input.behaviorId !== void 0) {
+		const behaviorOpt = yield* reader.getBehaviorById(input.behaviorId);
+		if (Option.isNone(behaviorOpt)) return {
 			accepted: false,
 			phase: currentPhase,
-			denialReason: "goal_not_in_tdd_task",
+			denialReason: "behavior_not_found",
 			remediation: {
-				suggestedTool: "tdd_goal",
+				suggestedTool: "tdd_behavior_list",
 				suggestedArgs: {
-					action: "list",
-					tddTaskId: input.tddTaskId
+					scope: "goal",
+					goalId: input.goalId
 				},
-				humanHint: `Goal id=${input.goalId} belongs to TDD task ${goalOpt.value.sessionId}, not the requested tddTaskId=${input.tddTaskId}. Pass the tddTaskId of the goal's parent task, or pick a goal that belongs to the active task.`
+				humanHint: `No tdd_session_behaviors row with id=${input.behaviorId}. Call tdd_behavior_list to find the correct behavior id.`
 			}
 		};
-		if (goalOpt.value.status !== "in_progress") return {
+		if (behaviorOpt.value.goalId !== input.goalId) return {
 			accepted: false,
 			phase: currentPhase,
-			denialReason: "goal_not_in_progress",
+			denialReason: "behavior_not_in_goal",
 			remediation: {
-				suggestedTool: "tdd_goal_update",
-				suggestedArgs: {
-					id: input.goalId,
-					status: "in_progress"
-				},
-				humanHint: `Goal id=${input.goalId} has status '${goalOpt.value.status}'. Phase transitions require the goal to be in_progress. Call tdd_goal_update({status:'in_progress'}) before requesting transitions.`
+				suggestedTool: "tdd_behavior_get",
+				suggestedArgs: { id: input.behaviorId },
+				humanHint: `Behavior id=${input.behaviorId} belongs to goal ${behaviorOpt.value.goalId}, not the requested goalId=${input.goalId}. Pass the goalId of the behavior's parent goal.`
 			}
 		};
-		if (input.behaviorId !== void 0) {
-			const behaviorOpt = yield* reader.getBehaviorById(input.behaviorId);
-			if (Option.isNone(behaviorOpt)) return {
-				accepted: false,
-				phase: currentPhase,
-				denialReason: "behavior_not_found",
-				remediation: {
-					suggestedTool: "tdd_behavior_list",
-					suggestedArgs: {
-						scope: "goal",
-						goalId: input.goalId
-					},
-					humanHint: `No tdd_session_behaviors row with id=${input.behaviorId}. Call tdd_behavior_list to find the correct behavior id.`
-				}
-			};
-			if (behaviorOpt.value.goalId !== input.goalId) return {
-				accepted: false,
-				phase: currentPhase,
-				denialReason: "behavior_not_in_goal",
-				remediation: {
-					suggestedTool: "tdd_behavior_get",
-					suggestedArgs: { id: input.behaviorId },
-					humanHint: `Behavior id=${input.behaviorId} belongs to goal ${behaviorOpt.value.goalId}, not the requested goalId=${input.goalId}. Pass the goalId of the behavior's parent goal.`
-				}
-			};
-		}
-		const requiredKindForTransition = requiredArtifactForTransition(currentPhase, input.requestedPhase);
-		let resolvedArtifactId;
-		let resolvedKindSource = "none";
-		let kindToLookUp;
-		if (input.citedArtifactId !== void 0) {
-			resolvedArtifactId = input.citedArtifactId;
-			resolvedKindSource = "explicit-id";
-		} else if (input.citedArtifactKind !== void 0) {
-			kindToLookUp = input.citedArtifactKind;
-			resolvedKindSource = "explicit-kind";
-		} else if (requiredKindForTransition !== null) {
-			kindToLookUp = requiredKindForTransition.kind;
-			resolvedKindSource = "transition-derived";
-		}
-		const scopeLookupByBehavior = input.behaviorId !== void 0 && transitionEnforcesBehaviorMatch(currentPhase, input.requestedPhase);
-		if (resolvedArtifactId === void 0 && kindToLookUp !== void 0) {
-			const recent = yield* reader.listTddArtifactsForTask({
+	}
+	const requiredKindForTransition = requiredArtifactForTransition(currentPhase, input.requestedPhase);
+	let resolvedArtifactId;
+	let resolvedKindSource = "none";
+	let kindToLookUp;
+	if (input.citedArtifactId !== void 0) {
+		resolvedArtifactId = input.citedArtifactId;
+		resolvedKindSource = "explicit-id";
+	} else if (input.citedArtifactKind !== void 0) {
+		kindToLookUp = input.citedArtifactKind;
+		resolvedKindSource = "explicit-kind";
+	} else if (requiredKindForTransition !== null) {
+		kindToLookUp = requiredKindForTransition.kind;
+		resolvedKindSource = "transition-derived";
+	}
+	const scopeLookupByBehavior = input.behaviorId !== void 0 && transitionEnforcesBehaviorMatch(currentPhase, input.requestedPhase);
+	if (resolvedArtifactId === void 0 && kindToLookUp !== void 0) {
+		const recent = yield* reader.listTddArtifactsForTask({
+			tddTaskId: input.tddTaskId,
+			artifactKind: kindToLookUp,
+			...scopeLookupByBehavior && { behaviorId: input.behaviorId },
+			limit: 1
+		});
+		if (recent.length === 0) {
+			const sinceIso = (/* @__PURE__ */ new Date(Date.now() - DIAGNOSTIC_WINDOW_MINUTES * 6e4)).toISOString();
+			const crossSessionCount = yield* reader.countRecentArtifactsInOtherSessionsOfConversation({
 				tddTaskId: input.tddTaskId,
-				artifactKind: kindToLookUp,
-				...scopeLookupByBehavior && { behaviorId: input.behaviorId },
-				limit: 1
+				sinceIso
 			});
-			if (recent.length === 0) {
-				const sinceIso = (/* @__PURE__ */ new Date(Date.now() - DIAGNOSTIC_WINDOW_MINUTES * 6e4)).toISOString();
-				const crossSessionCount = yield* reader.countRecentArtifactsInOtherSessionsOfConversation({
-					tddTaskId: input.tddTaskId,
-					sinceIso
-				});
-				const baseHint = `No '${kindToLookUp}' artifact has been recorded for tdd_task ${input.tddTaskId}. Artifacts are recorded by hooks observing your tool calls (Decision D7) — run the test (e.g. via run_tests) or make the file edit first; the post-tool-use hook will write the matching tdd_artifacts row and the next call to this tool will pick it up automatically.`;
-				return {
-					accepted: false,
-					phase: currentPhase,
-					denialReason: "missing_artifact_evidence",
-					remediation: {
-						suggestedTool: "run_tests",
-						suggestedArgs: {},
-						humanHint: crossSessionCount > 0 ? `${baseHint} ${crossSessionCount} artifact${crossSessionCount === 1 ? " was" : "s were"} recorded under a different session of this conversation in the last ${DIAGNOSTIC_WINDOW_MINUTES} minutes — the subagent's hooks may be attributing to a detached session; set VITEST_AGENT_TDD_TASK_ID=${input.tddTaskId} in the subagent's environment or dispatch it as an unnamed background subagent.` : baseHint
-					}
-				};
-			}
-			resolvedArtifactId = recent[0].id;
-		}
-		let citedArtifact;
-		if (resolvedArtifactId !== void 0) {
-			const artifactOpt = yield* reader.getTddArtifactWithContext(resolvedArtifactId);
-			if (Option.isNone(artifactOpt)) return {
+			const baseHint = `No '${kindToLookUp}' artifact has been recorded for tdd_task ${input.tddTaskId}. Artifacts are recorded by hooks observing your tool calls (Decision D7) — run the test (e.g. via run_tests) or make the file edit first; the post-tool-use hook will write the matching tdd_artifacts row and the next call to this tool will pick it up automatically.`;
+			return {
 				accepted: false,
 				phase: currentPhase,
 				denialReason: "missing_artifact_evidence",
 				remediation: {
 					suggestedTool: "run_tests",
 					suggestedArgs: {},
-					humanHint: `Cited artifact id ${resolvedArtifactId} does not exist. Artifacts are recorded by hooks observing your tool calls (Decision D7), so run the test (e.g. via the run_tests MCP tool) or make the file edit first; the post-tool-use hook will write the matching tdd_artifacts row and return its id, which can then be cited here.`
+					humanHint: crossSessionCount > 0 ? `${baseHint} ${crossSessionCount} artifact${crossSessionCount === 1 ? " was" : "s were"} recorded under a different session of this conversation in the last ${DIAGNOSTIC_WINDOW_MINUTES} minutes — the subagent's hooks may be attributing to a detached session; set VITEST_AGENT_TDD_TASK_ID=${input.tddTaskId} in the subagent's environment or dispatch it as an unnamed background subagent.` : baseHint
 				}
 			};
-			citedArtifact = artifactOpt.value;
-		} else citedArtifact = {
-			id: -1,
-			phase_id: -1,
-			artifact_kind: "test_written",
-			test_case_id: null,
-			test_case_created_turn_at: null,
-			test_case_authored_in_session: false,
-			test_run_id: null,
-			test_first_failure_run_id: null,
-			behavior_id: null,
-			suite: "vitest"
-		};
-		const result = validatePhaseTransition({
-			tdd_task_id: input.tddTaskId,
-			current_phase: currentPhase,
-			current_phase_id: currentPhaseId,
-			phase_started_at: phaseStartedAt,
-			now: (/* @__PURE__ */ new Date()).toISOString(),
-			requested_phase: input.requestedPhase,
-			cited_artifact: citedArtifact,
-			requested_behavior_id: input.behaviorId ?? null
-		});
-		if (!result.accepted) return result;
-		const out = yield* store.writeTddPhase({
-			tddTaskId: input.tddTaskId,
-			phase: result.phase,
-			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			...input.behaviorId !== void 0 && { behaviorId: input.behaviorId },
-			...input.reason !== void 0 && { transitionReason: input.reason }
-		});
-		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,
-			newPhaseId: out.id,
-			previousPhaseId: out.previousPhaseId,
-			...resolvedArtifactId !== void 0 && {
-				citedArtifactId: resolvedArtifactId,
-				citedArtifactSource: resolvedKindSource
+		}
+		resolvedArtifactId = recent[0].id;
+	}
+	let citedArtifact;
+	if (resolvedArtifactId !== void 0) {
+		const artifactOpt = yield* reader.getTddArtifactWithContext(resolvedArtifactId);
+		if (Option.isNone(artifactOpt)) return {
+			accepted: false,
+			phase: currentPhase,
+			denialReason: "missing_artifact_evidence",
+			remediation: {
+				suggestedTool: "run_tests",
+				suggestedArgs: {},
+				humanHint: `Cited artifact id ${resolvedArtifactId} does not exist. Artifacts are recorded by hooks observing your tool calls (Decision D7), so run the test (e.g. via the run_tests MCP tool) or make the file edit first; the post-tool-use hook will write the matching tdd_artifacts row and return its id, which can then be cited here.`
 			}
 		};
-	}));
-});
+		citedArtifact = artifactOpt.value;
+	} else citedArtifact = {
+		id: -1,
+		phase_id: -1,
+		artifact_kind: "test_written",
+		test_case_id: null,
+		test_case_created_turn_at: null,
+		test_case_authored_in_session: false,
+		test_run_id: null,
+		test_first_failure_run_id: null,
+		behavior_id: null,
+		suite: "vitest"
+	};
+	const result = validatePhaseTransition({
+		tdd_task_id: input.tddTaskId,
+		current_phase: currentPhase,
+		current_phase_id: currentPhaseId,
+		phase_started_at: phaseStartedAt,
+		now: (/* @__PURE__ */ new Date()).toISOString(),
+		requested_phase: input.requestedPhase,
+		cited_artifact: citedArtifact,
+		requested_behavior_id: input.behaviorId ?? null
+	});
+	if (!result.accepted) return result;
+	const out = yield* store.writeTddPhase({
+		tddTaskId: input.tddTaskId,
+		phase: result.phase,
+		startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		...input.behaviorId !== void 0 && { behaviorId: input.behaviorId },
+		...input.reason !== void 0 && { transitionReason: input.reason }
+	});
+	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,
+		newPhaseId: out.id,
+		previousPhaseId: out.previousPhaseId,
+		...resolvedArtifactId !== void 0 && {
+			citedArtifactId: resolvedArtifactId,
+			citedArtifactSource: resolvedKindSource
+		}
+	};
+}).pipe(Effect.orDie);
+/**
+* The Effect-native `tdd_phase_transition_request` tool.
+*
+* @public
+*/
+const tddPhaseTransitionRequestTool = Tool.make("tdd_phase_transition_request", {
+	description: "Use when advancing a TDD cycle and you need a phase transition validated and recorded. Validates goal status, behavior↔goal membership, and D2 artifact-evidence binding rules; returns accept/deny. On accept, auto-promotes a behavior 'pending' → 'in_progress' when behaviorId is supplied. citedArtifactId is OPTIONAL — when omitted, the most recent matching artifact is auto-resolved (kind comes from citedArtifactKind if supplied, otherwise from the transition's required-evidence rule). Transitions like spike→red that require no artifact need neither field. The accepted response echoes citedArtifactId + citedArtifactSource so the caller can see which row was picked.",
+	parameters: PhaseTransitionInput,
+	success: PhaseTransitionResult,
+	dependencies: [DataReader, DataStore]
+}).annotate(Tool.Title, "TDD phase transition request").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => JSON.stringify(encoded, null, 2));
 
 //#endregion
-export { PhaseTransitionResult, tddPhaseTransitionRequest };
+export { PhaseTransitionInput, PhaseTransitionResult, handlePhaseTransitionRequest, tddPhaseTransitionRequestTool };

package/tools/tdd-progress-push.js

@@ -0,0 +1,102 @@
+import { RenderText } from "../annotations.js";
+import { Effect, Option, Schema } from "effect";
+import { DataReader } from "@vitest-agent/engine";
+import { McpServer, Tool } from "effect/unstable/ai";
+import { ChannelEvent } from "@vitest-agent/sdk";
+
+//#region src/tools/tdd-progress-push.ts
+/**
+* The `tdd_progress_push` tool's parameters.
+*
+* @public
+*/
+const TddProgressPushInput = Schema.Struct({ payload: Schema.String.annotate({ description: "Pre-stringified ChannelEvent JSON (see schemas/ChannelEvent in @vitest-agent/sdk)" }) });
+/**
+* The `tdd_progress_push` result — always `{ ok: true }`.
+*
+* @public
+*/
+const TddProgressPushResult = Schema.Struct({ ok: Schema.Literal(true) }).annotate({
+	identifier: "TddProgressPushResult",
+	title: "tdd_progress_push result",
+	description: "Always ok:true — the push is best-effort and never reports delivery."
+});
+/** The logger name every channel notification is published under. */
+const CHANNEL_LOGGER = "vitest-agent/channel";
+/**
+* For behavior-scoped events, resolve goalId/sessionId server-side from
+* behaviorId so a stale orchestrator context cannot push the wrong tree
+* coordinates. Goal-scoped events get sessionId resolved from goalId.
+* Returns the enriched event object or the original on resolution failure.
+*
+* @internal
+*/
+const resolveChannelEvent = (raw) => Effect.gen(function* () {
+	const decoded = yield* Schema.decodeUnknownEffect(ChannelEvent)(raw).pipe(Effect.option);
+	if (Option.isNone(decoded)) return raw;
+	const event = decoded.value;
+	const reader = yield* DataReader;
+	return yield* Effect.gen(function* () {
+		switch (event.type) {
+			case "behavior_started":
+			case "phase_transition":
+			case "behavior_completed":
+			case "behavior_abandoned":
+			case "blocked": {
+				const goalIdOpt = yield* reader.resolveGoalIdForBehavior(event.behaviorId);
+				if (Option.isNone(goalIdOpt)) return event;
+				const goalDetailOpt = yield* reader.getGoalById(goalIdOpt.value);
+				if (Option.isNone(goalDetailOpt)) return event;
+				return {
+					...event,
+					goalId: goalIdOpt.value,
+					sessionId: goalDetailOpt.value.sessionId
+				};
+			}
+			case "goal_started":
+			case "goal_completed":
+			case "goal_abandoned": {
+				const goalDetailOpt = yield* reader.getGoalById(event.goalId);
+				if (Option.isNone(goalDetailOpt)) return event;
+				return {
+					...event,
+					sessionId: goalDetailOpt.value.sessionId
+				};
+			}
+			default: return event;
+		}
+	}).pipe(Effect.orElseSucceed(() => event));
+});
+/**
+* Handler for {@link tddProgressPushTool}. Malformed JSON is forwarded as
+* the raw string; a DB read failure forwards the decoded event unenriched;
+* a notification failure (no initialized client, transport gone) is
+* ignored. The result is `{ ok: true }` on every path.
+*
+* @public
+*/
+const handleTddProgressPush = (input) => Effect.gen(function* () {
+	const server = yield* McpServer.McpServer;
+	const parsed = yield* Effect.try(() => JSON.parse(input.payload)).pipe(Effect.option);
+	const data = Option.isSome(parsed) ? yield* resolveChannelEvent(parsed.value) : input.payload;
+	yield* server.notifications["notifications/message"]({
+		level: "info",
+		logger: CHANNEL_LOGGER,
+		data
+	}).pipe(Effect.ignore);
+	return { ok: true };
+});
+/**
+* The Effect-native `tdd_progress_push` tool.
+*
+* @public
+*/
+const tddProgressPushTool = Tool.make("tdd_progress_push", {
+	description: "Use when a TDD orchestrator needs to report progress to the main agent over a Claude Code channel. The MCP server validates the payload against the ChannelEvent union and resolves goalId/sessionId server-side from behaviorId for behavior-scoped events (so a stale orchestrator context cannot push the wrong tree coordinates). Best-effort — returns { ok: true } regardless of whether channels are active.",
+	parameters: TddProgressPushInput,
+	success: TddProgressPushResult,
+	dependencies: [DataReader, McpServer.McpServer]
+}).annotate(Tool.Title, "TDD progress push").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, false).annotate(RenderText, (encoded) => JSON.stringify(encoded, null, 2));
+
+//#endregion
+export { CHANNEL_LOGGER, TddProgressPushInput, TddProgressPushResult, handleTddProgressPush, resolveChannelEvent, tddProgressPushTool };