tdd-enforcer 0.2.8 → 0.2.9

package/adapters/pi/hooks.ts

@@ -120,7 +120,7 @@ export async function handleToolCall(
 		return {
 			block: true,
 			reason:
-				"TDD: Config files are locked. No bypassing TDD allowed. If bypassing is justified, ask the user: turn TDD off (/tdd:off), reset (/tdd:reset), or change phase via /tdd commands.",
+				"TDD: Config files are locked. No bypassing TDD allowed. If bypassing is justified, ask the user: turn TDD off (/tdd:off), reset (/tdd:reset), or change phase via /tdd commands.\n\nIf TDD reverts too much of your progress, reduce the scope of each TDD cycle to minimise lost progress.",
 		};
 	}
 
@@ -267,6 +267,9 @@ function formatWarning(
 		.join("");
 	let warning = `\n\n⛔ ${phase.toUpperCase()}: reverted locked files modified by bash:`;
 	for (const f of cmdViolations) warning += `\n  - ${f}`;
+	if (cmdViolations.some((f) => f.startsWith(".pi/tdd/"))) {
+		warning += `\n\nIf TDD reverts too much of your progress, reduce the scope of each TDD cycle to minimise lost progress.`;
+	}
 	if (cmdAllowed.length > 0) {
 		warning += `\n\nAllowed changes retained:`;
 		for (const f of cmdAllowed) warning += `\n  - ${f}`;

package/adapters/pi/index.test.ts

@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import {
+	handleBeforeAgentStart,
 	handleTddJump,
 	handleTddOff,
 	handleTddOn,
@@ -416,3 +417,90 @@ describe("handleTddJump", () => {
 		expect(ctx.notifications[0].message).toContain("Skipped to RED phase");
 	});
 });
+
+// ── handleBeforeAgentStart ──────────────────────────────────────────────────
+
+describe("handleBeforeAgentStart", () => {
+	let mockLoadTddState: ReturnType<typeof vi.fn>;
+
+	function makeDeps(overrides = {}) {
+		return {
+			loadTddState: mockLoadTddState,
+			...overrides,
+		};
+	}
+
+	function makeEvent(): {
+		systemPromptOptions: { promptGuidelines: string[] };
+	} {
+		return { systemPromptOptions: { promptGuidelines: [] } };
+	}
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		mockLoadTddState = vi.fn();
+	});
+
+	it("pushes guidelines when TDD enabled", async () => {
+		mockLoadTddState.mockReturnValue({
+			ok: true,
+			state: { enabled: true, current: "red" },
+			config: {
+				blockedInRed: [],
+				blockedInGreen: [],
+				testCommands: [],
+				timeoutSeconds: 30,
+			},
+		});
+		const event = makeEvent();
+		await handleBeforeAgentStart(
+			event as any,
+			{ cwd: "/test" } as any,
+			makeDeps(),
+		);
+		expect(event.systemPromptOptions.promptGuidelines).toHaveLength(3);
+		expect(event.systemPromptOptions.promptGuidelines[0]).toContain(
+			"locked files will be blocked",
+		);
+		expect(event.systemPromptOptions.promptGuidelines[1]).toContain(
+			"next_tdd_phase",
+		);
+		expect(event.systemPromptOptions.promptGuidelines[2]).toContain(
+			"cycle so reverting is cheap",
+		);
+	});
+
+	it("does not push guidelines when TDD not setup", async () => {
+		mockLoadTddState.mockReturnValue({
+			ok: false,
+			reason: "Missing .pi/tdd/",
+		});
+		const event = makeEvent();
+		await handleBeforeAgentStart(
+			event as any,
+			{ cwd: "/test" } as any,
+			makeDeps(),
+		);
+		expect(event.systemPromptOptions.promptGuidelines).toHaveLength(0);
+	});
+
+	it("does not push guidelines when TDD disabled", async () => {
+		mockLoadTddState.mockReturnValue({
+			ok: true,
+			state: { enabled: false, current: "red" },
+			config: {
+				blockedInRed: [],
+				blockedInGreen: [],
+				testCommands: [],
+				timeoutSeconds: 30,
+			},
+		});
+		const event = makeEvent();
+		await handleBeforeAgentStart(
+			event as any,
+			{ cwd: "/test" } as any,
+			makeDeps(),
+		);
+		expect(event.systemPromptOptions.promptGuidelines).toHaveLength(0);
+	});
+});

package/adapters/pi/index.ts

@@ -148,6 +148,25 @@ export async function handleTddStatus(
 	);
 }
 
+export async function handleBeforeAgentStart(
+	event: {
+		systemPromptOptions: { promptGuidelines: string[] };
+	},
+	ctx: { cwd: string },
+	deps: {
+		loadTddState: typeof loadTddState;
+	},
+): Promise<void> {
+	const tdd = deps.loadTddState(ctx.cwd);
+	if (!tdd.ok || !tdd.state.enabled) return;
+
+	event.systemPromptOptions.promptGuidelines.push(
+		"You are working under TDD enforcement. Each phase restricts which files you can modify — locked files will be blocked automatically.",
+		"Use `next_tdd_phase` to advance through the cycle, `previous_tdd_phase` to revert a phase, `tdd_status` to check current phase and blocked file rules.",
+		"Minimise the scope of each TDD cycle so reverting is cheap.",
+	);
+}
+
 export async function handleTddJump(
 	phase: "red" | "green" | "refactor",
 	ctx: ExtensionContext,
@@ -303,4 +322,8 @@ export default function (pi: ExtensionAPI) {
 
 	registerTools(pi);
 	registerHooks(pi);
+
+	pi.on("before_agent_start", (event, ctx) =>
+		handleBeforeAgentStart(event, ctx, { loadTddState }),
+	);
 }

package/adapters/pi/prompts.ts

@@ -12,7 +12,7 @@ export function getNudgePrompt(phase: Phase, config: Config): string {
 				"All other files are free to modify. Call `next_tdd_phase` to proceed to GREEN.\n" +
 				"Think about what could go wrong and test for it — don't just verify the happy path, " +
 				"cover unhappy paths and edge cases too.\n" +
-				"Keep cycles small so reverting is cheap."
+				"Minimise the scope of each TDD cycle so reverting is cheap."
 			);
 		case "green":
 			return (

package/adapters/pi/tools.test.ts

@@ -137,6 +137,21 @@ describe("executeNextPhase", () => {
 		).rejects.toThrow("failed");
 	});
 
+	it("result text has leading newline for spacing", async () => {
+		mockLoadTddState.mockReturnValue({
+			ok: true,
+			state: { enabled: true, current: "red" },
+			config: CONFIG,
+		});
+		mockCheckGate.mockResolvedValue({
+			passed: true,
+			message: "Tests fail — proceed to GREEN.",
+		});
+		mockGetNudgePrompt.mockReturnValue("content");
+		const result = await executeNextPhase({ cwd: "/test" } as any, makeDeps());
+		expect(result.content[0].text.startsWith("\n")).toBe(true);
+	});
+
 	it("advances red→green when tests fail", async () => {
 		mockLoadTddState.mockReturnValue({
 			ok: true,

package/adapters/pi/tools.ts

@@ -178,7 +178,7 @@ export async function executeNextPhase(
 	deps.tddLog(tddDir, "INFO", "next_tdd_phase: complete", { from, to });
 
 	return {
-		content: [{ type: "text", text: deps.getNudgePrompt(to, config) }],
+		content: [{ type: "text", text: `\n${deps.getNudgePrompt(to, config)}` }],
 		details: {},
 	};
 }
@@ -266,7 +266,7 @@ export async function executePreviousPhase(
 		content: [
 			{
 				type: "text",
-				text: `Reverted to ${prevPhase.toUpperCase()}. Working tree has the previous snapshot content as unstaged changes.`,
+				text: `\nReverted to ${prevPhase.toUpperCase()}. Working tree has the previous snapshot content as unstaged changes.`,
 			},
 		],
 		details: {},
@@ -312,7 +312,7 @@ export async function executeTddStatus(
 			{
 				type: "text",
 				text:
-					`TDD enforcer enabled\n` +
+					`\nTDD enforcer enabled\n` +
 					`Current phase: ${phaseStr}\n` +
 					`Blocked in RED: ${redBlk}\n` +
 					`Blocked in GREEN: ${greenBlk}\n` +

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "tdd-enforcer",
-	"version": "0.2.8",
+	"version": "0.2.9",
 	"type": "module",
 	"scripts": {
 		"fmt": "biome format --write .",

package/skills/tdd-enforcer/SKILL.md

@@ -54,7 +54,7 @@ It locks files per phase — only test files in RED, only implementation files i
 ### RED
 Files matching `blockedInRed` are locked — everything else is free.
 
-Write failing tests for one feature at a time. Think about what could go wrong and test for it — don't just verify the happy path, cover unhappy paths and edge cases too. Keep cycles small so reverting is cheap and safe if assumptions turn out wrong.
+Write failing tests for one feature at a time. Think about what could go wrong and test for it — don't just verify the happy path, cover unhappy paths and edge cases too. Minimise the scope of each TDD cycle so reverting is cheap and safe if assumptions turn out wrong.
 
 Call `next_tdd_phase` once tests fail.