tdd-enforcer 0.3.3 → 0.3.5

package/README.md

@@ -0,0 +1,169 @@
+# tdd-enforcer
+
+**Lock files per TDD phase. Gate transitions on test outcomes.**
+
+[![CI](https://github.com/Cyclone1070/tdd-enforcer/actions/workflows/ci.yml/badge.svg)](https://github.com/Cyclone1070/tdd-enforcer/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/tdd-enforcer.svg)](https://www.npmjs.com/package/tdd-enforcer)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+---
+
+## Features
+
+- **Phase-locked file access** — prevents the agent from modifying test files in GREEN and implementation files in RED. Everything is open in REFACTOR
+- **Guards all file-modifying tools** — `write`, `edit`, and `bash` are all intercepted. All invalid modifications are blocked.
+- **Automatic transition gates** — advancing to the next phase requires tests to fail (RED→GREEN) or pass (GREEN→REFACTOR, REFACTOR→RED). Misconfigured or broken transitions are rejected
+- **Safe rollback** — if the previous phase's work was wrong, reverting discards all current changes and restores the exact working tree from before that phase
+- **Stays out of your way** — TDD enforcement is opt-in (`/tdd:on`). Disable anytime with `/tdd:off` to unlock all files
+- **Version-controlled config** — `.pi/tdd/rules.json` lives in your repo alongside the code, so the whole team shares the same rules
+
+---
+
+## Setup
+
+### 1. Install
+
+```bash
+pi install npm:tdd-enforcer
+```
+
+### 2. Ask the agent to set up TDD
+
+Tell the agent to configure TDD for your project, using the tdd-enforcer skill to create `.pi/tdd/rules.json` with the right file globs and test commands for your stack.
+
+### 3. Enable TDD
+
+Once configured, run:
+
+```
+/tdd:on
+```
+
+### Config reference
+
+`.pi/tdd/rules.json` fields (created by the agent, not manually):
+
+| Field | Description |
+|-------|-------------|
+| `blockedInRed` | Globs the agent **cannot** touch in RED phase (implementation files) |
+| `blockedInGreen` | Globs the agent **cannot** touch in GREEN phase (test files) |
+| `!` prefix | Exclusion: carves out subsets from a block (e.g. co-located test files) |
+| `testCommands` | Commands run in parallel for gate checks. Exit 0 = pass, non-zero = block. Use `&&` inside a single entry to chain dependent steps |
+| `timeoutSeconds` | Test timeout per command (default: 120) |
+
+---
+
+## Usage
+
+### User commands
+
+| Command | Description |
+|---------|-------------|
+| `/tdd:on` | Enable TDD enforcement |
+| `/tdd:off` | Disable TDD enforcement, all files become free |
+| `/tdd:status` | Show phase, blocked globs, test commands |
+| `/tdd:reset` | **Destructive**: nukes all snapshot history, resets to RED (disabled) |
+| `/tdd:red`, `/tdd:green`, `/tdd:refactor` | Skip to a given phase (auto-enables, no gate checks) |
+
+### Agent tools
+
+| Tool | When to use | Effect |
+|------|-------------|--------|
+| `next_tdd_phase` | Current phase work is complete | Runs allowlist check + gate test, snapshots state, advances phase|
+| `previous_tdd_phase` | Previous phase work was wrong | **Discards all current-phase changes**, restores working tree to previous snapshot |
+| `tdd_status` | Check current enforcement state | Returns phase, blocked globs, test commands |
+
+---
+
+## How it works
+
+Uses a **private git repository** at `.pi/tdd/.git/` (separate from your project's real git history) to detect locked-file changes, revert invalid modifications, and track state across phase transitions.
+
+```
+                 tests fail                  tests pass
+     ┌──────┐    (gate check)    ┌────────┐  (gate check)   ┌──────────┐
+     │ RED  │ ──────────────────▶│ GREEN  │ ───────────────▶│ REFACTOR │
+     │(test)│                    │ (impl) │                 │(cleanup) │
+     └──────┘                    └────────┘                 └──────────┘
+        ▲                                                        │
+        └────────────────────────────────────────────────────────┘
+                                tests pass
+```
+
+Every phase transition runs two validations before advancing:
+
+1. **Allowlist check** — scans working tree changes against the phase's blocked globs. If any locked file has been modified, the transition is rejected with the violating paths listed
+2. **Gate check** — runs `testCommands` in parallel. The required outcome depends on the transition:
+   - RED→GREEN: all commands must fail (a passing test suite means there's no failing test to justify moving to GREEN)
+   - GREEN→REFACTOR: all commands must pass
+   - REFACTOR→RED: all commands must pass
+
+If both checks pass, the working tree is snapshotted and the phase advances.
+
+### File-level enforcement
+
+When TDD is active, every `write`, `edit`, and `bash` tool call is intercepted:
+
+- **`write` / `edit`** — the target file path is checked against the current phase's blocked globs before the tool executes. Locked file writes are blocked with an error message
+- **`bash`** — the working tree is stashed before the command runs. After it finishes, the diff is compared against the stash to find what changed. Any locked-file modifications are automatically reverted, and the command output is amended with a warning listing the violations
+
+This means the agent can attempt any change — enforcement happens transparently at the tool layer.
+
+### Rollback mechanics
+
+Each phase transition creates a labeled commit in a private git repository at `.pi/tdd/.git/`. Calling `previous_tdd_phase`:
+
+1. Confirms HEAD is a TDD snapshot (commit message starts with `tdd: {phase}`)
+2. Hard-resets the working tree to discard uncommitted changes
+3. Soft-resets HEAD~1 to pop the snapshot
+4. Sets the phase back
+
+Since TDD owns its own git repo, rollback doesn't touch the project's real git history at all.
+
+### State recovery
+
+If `state.json` is missing or corrupted, the extension recovers by reading the last TDD commit message from `.pi/tdd/.git/`. The label (`tdd: red`, `tdd: green`, etc.) determines the current phase. If no TDD commits exist, it defaults to disabled in RED.
+
+---
+
+## Development
+
+```bash
+npm install
+npm run check
+```
+
+### Project structure
+
+```
+tdd-enforcer/
+├── engine/                  # Framework-agnostic core
+│   ├── types.ts             # Phase, Config, Transition types
+│   ├── config.ts            # Load & validate rules.json
+│   ├── state.ts             # Load/save/recover phase state
+│   ├── enforce.ts           # Glob-based file allowlist checks
+│   ├── transition.ts        # Gate checks (test failure/pass per transition)
+│   ├── orchestrate.ts       # advancePhase / revertPhase orchestration
+│   ├── git.ts               # Private git repo for snapshots & diff
+│   ├── log.ts               # Append-only log with line cap
+│   └── prompts.ts           # Phase-specific agent nudges
+├── adapters/
+│   └── pi/                  # pi extension adapter
+│       ├── index.ts         # Extension entry: commands (tdd:on/off/status/reset/jump)
+│       ├── hooks.ts         # Intercept write/edit/bash tool calls & results
+│       └── tools.ts         # Agent tools: next_tdd_phase, previous_tdd_phase, tdd_status
+├── skills/
+│   └── tdd-enforcer/
+│       └── SKILL.md         # Agent instructions for TDD workflows
+└── package.json
+```
+
+- `engine/` — pure logic, zero pi dependencies. Testable in isolation
+- `adapters/pi/` — pi-specific wiring: commands, hooks, agent tools
+- `skills/tdd-enforcer/` — agent instructions consumed at runtime
+
+---
+
+## License
+
+[MIT](LICENSE)

package/adapters/pi/hooks.ts

@@ -13,9 +13,8 @@ import {
 	gitStashCreate,
 	restoreFilesTo,
 } from "../../engine/git.js";
+import { loadTddState, tddLog } from "../../engine/index.js";
 import type { Config, Phase } from "../../engine/types.js";
-import { loadTddState } from "./helpers.js";
-import { tddLog } from "./log.js";
 
 export async function handleToolCall(
 	event: any,

package/adapters/pi/index.ts

@@ -3,10 +3,14 @@ import type {
 	ExtensionAPI,
 	ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
-import { resetGit, savePhaseState, snapshot } from "../../engine/index.js";
-import { loadTddState } from "./helpers.js";
+import {
+	loadTddState,
+	resetGit,
+	savePhaseState,
+	snapshot,
+	tddLog,
+} from "../../engine/index.js";
 import { registerHooks } from "./hooks.js";
-import { tddLog } from "./log.js";
 import { registerTools } from "./tools.js";
 
 export async function handleTddOn(

package/adapters/pi/tools.test.ts

@@ -172,6 +172,25 @@ describe("executeNextPhase", () => {
 		});
 	});
 
+	it("blocks on timeout with timeout message from checkGate", async () => {
+		mockLoadTddState.mockReturnValue({
+			ok: true,
+			state: { enabled: true, current: "red" },
+			config: CONFIG,
+		});
+		mockCheckGate.mockResolvedValue({
+			passed: false,
+			timeout: true,
+			message:
+				"Tests timed out after 30s. The test command may have hung or an operation may be blocking.",
+		});
+		await expect(
+			executeNextPhase({ cwd: "/test" } as any, makeDeps()),
+		).rejects.toThrow("timed out");
+		expect(mockSnapshot).not.toHaveBeenCalled();
+		expect(mockSavePhaseState).not.toHaveBeenCalled();
+	});
+
 	it("advances green→refactor when tests pass", async () => {
 		mockLoadTddState.mockReturnValue({
 			ok: true,

package/adapters/pi/tools.ts

@@ -11,19 +11,22 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 import type { Phase, TestRunner } from "../../engine/index.js";
 import {
+	advancePhase,
 	checkGate,
 	getDisallowedChanges,
+	getNudgePrompt,
+	getStatusInfo,
 	hasParent,
 	headMessage,
+	loadTddState,
 	nextPhase,
 	resetHard,
+	revertPhase,
 	savePhaseState,
 	snapshot,
+	tddLog,
 	undoLastCommit,
 } from "../../engine/index.js";
-import { loadTddState } from "./helpers.js";
-import { tddLog } from "./log.js";
-import { getNudgePrompt } from "./prompts.js";
 
 // ── De dependency types ─────────────────────────────────────────────────────
 
@@ -115,34 +118,37 @@ export async function executeNextPhase(
 
 	deps.tddLog(tddDir, "INFO", "next_tdd_phase: starting", { from, to });
 
-	// 1. Allowlist check
-	const violations = deps.getDisallowedChanges(root, from, config);
-	if (violations.length > 0) {
-		deps.tddLog(tddDir, "WARN", "next_tdd_phase: blocked by allowlist", {
-			from,
-			violations,
-		});
-		throw new Error(
-			`BLOCKED: files not allowed in ${from.toUpperCase()} phase:\n` +
-				violations.map((f) => `  - ${f}`).join("\n") +
-				`\nRevert or remove them before proceeding.\n\nInspect with: cd .pi/tdd && git diff HEAD -- ${violations[0]}`,
-		);
-	}
-
-	// 2. Gate check
 	const testRunner: TestRunner = async (commands, timeout) => {
 		const results = await Promise.all(
 			commands.map(async (cmd) => {
 				try {
-					await deps.asyncExec(cmd, { cwd: root, timeout: timeout * 1000 });
-					return { command: cmd, passed: true };
-				} catch {
-					return { command: cmd, passed: false };
+					await deps.asyncExec(cmd, {
+						cwd: root,
+						timeout: timeout * 1000,
+					});
+					return { command: cmd, passed: true, timedOut: false } as const;
+				} catch (err) {
+					const timedOut = (err as any)?.killed === true;
+					return {
+						command: cmd,
+						passed: false,
+						timedOut,
+					} as const;
 				}
 			}),
 		);
 
-		const failed = results.filter((r) => !r.passed);
+		const timedOut = results.filter((r) => r.timedOut);
+		const failed = results.filter((r) => !r.passed && !r.timedOut);
+
+		if (timedOut.length > 0) {
+			return {
+				passed: false,
+				timeout: true,
+				message: `Tests timed out after ${timeout}s:\n${timedOut.map((f) => `  - ${f.command}`).join("\n")}`,
+			};
+		}
+
 		if (failed.length > 0) {
 			return {
 				passed: false,
@@ -152,31 +158,30 @@ export async function executeNextPhase(
 		return { passed: true, message: "All tests passed." };
 	};
 
-	const gate = await deps.checkGate(from, to, testRunner, config);
-	deps.tddLog(tddDir, "DEBUG", "next_tdd_phase: gate result", {
-		from,
-		to,
-		passed: gate.passed,
-		message: gate.message,
+	const result = await advancePhase(root, state, config, {
+		nextPhase: deps.nextPhase,
+		getDisallowedChanges: deps.getDisallowedChanges,
+		checkGate: deps.checkGate,
+		snapshot: deps.snapshot,
+		savePhaseState: deps.savePhaseState,
+		testRunner,
 	});
 
-	if (!gate.passed) {
-		throw new Error(gate.message);
+	if (!result.ok) {
+		// advancePhase already returns the exact error message with revert hint
+		// Log the failure at adapter level
+		deps.tddLog(tddDir, "WARN", "next_tdd_phase: blocked by allowlist", {
+			from,
+			violations: result.message,
+		});
+		throw new Error(result.message);
 	}
 
-	// 3. Snapshot — label with the phase the work was done in
-	const hash = deps.snapshot(root, from);
-	deps.tddLog(tddDir, "INFO", "next_tdd_phase: snapshot created", {
+	deps.tddLog(tddDir, "INFO", "next_tdd_phase: complete", {
 		from,
 		to,
-		hash,
 	});
 
-	// 4. Save state
-	state.current = to;
-	deps.savePhaseState(root, state);
-	deps.tddLog(tddDir, "INFO", "next_tdd_phase: complete", { from, to });
-
 	return {
 		content: [{ type: "text", text: `\n${deps.getNudgePrompt(to, config)}` }],
 		details: {},
@@ -208,65 +213,28 @@ export async function executePreviousPhase(
 
 	const { state } = tdd;
 
-	if (!deps.hasParent(root)) {
-		deps.tddLog(tddDir, "WARN", "previous_tdd_phase: no parent commit", {
-			phase: state.current,
-		});
-		throw new Error("No previous phase to revert to.");
-	}
-
-	// Read phase from HEAD snapshot commit message (source of truth).
-	// Snapshot is labeled with the phase the work was done in, so we use
-	// it directly — no hardcoded phase map needed.
-	const headMsg = deps.headMessage(root);
-	const phaseMatch = headMsg.match(/^tdd: (red|green|refactor)/);
-	if (!phaseMatch) {
-		deps.tddLog(tddDir, "ERROR", "previous_tdd_phase: invalid HEAD message", {
-			headMsg,
-		});
-		throw new Error(
-			`HEAD commit "${headMsg}" is not a TDD snapshot. Cannot determine previous phase.\n` +
-				`The private git repo at .pi/tdd must not be manually modified. ` +
-				`Tampering with it will cause TDD state corruption.`,
-		);
-	}
-	const label = phaseMatch[1];
-	if (label !== "red" && label !== "green" && label !== "refactor") {
-		deps.tddLog(tddDir, "ERROR", "previous_tdd_phase: invalid phase label", {
-			headMsg,
-			label,
-		});
-		throw new Error(
-			`HEAD commit "${headMsg}" has unexpected label. Cannot determine previous phase.`,
-		);
-	}
-	const prevPhase: Phase = label;
-	deps.tddLog(tddDir, "INFO", "previous_tdd_phase: reverting", {
-		from: state.current,
-		to: prevPhase,
-		headMsg,
+	const result = await revertPhase(root, state, {
+		hasParent: deps.hasParent,
+		headMessage: deps.headMessage,
+		resetHard: deps.resetHard,
+		undoLastCommit: deps.undoLastCommit,
+		savePhaseState: deps.savePhaseState,
 	});
 
-	// 1. Nuke any uncommitted changes, WT matches HEAD
-	deps.resetHard(root);
-	deps.tddLog(tddDir, "DEBUG", "previous_tdd_phase: resetHard done");
-
-	// 2. Pop last snapshot commit, keep its content as unstaged
-	deps.undoLastCommit(root);
-	deps.tddLog(tddDir, "DEBUG", "previous_tdd_phase: undoLastCommit done");
+	if (!result.ok) {
+		throw new Error(result.message);
+	}
 
-	// 3. Update phase label from the snapshot's own label
-	state.current = prevPhase;
-	deps.savePhaseState(root, state);
 	deps.tddLog(tddDir, "INFO", "previous_tdd_phase: complete", {
-		to: prevPhase,
+		from: state.current,
+		to: result.newState?.current,
 	});
 
 	return {
 		content: [
 			{
 				type: "text",
-				text: `\nReverted to ${prevPhase.toUpperCase()}. Working tree has the previous snapshot content as unstaged changes.`,
+				text: `\n${result.message} Working tree has the previous snapshot content as unstaged changes.`,
 			},
 		],
 		details: {},
@@ -293,11 +261,7 @@ export async function executeTddStatus(
 		throw new Error(`TDD: ${result.reason}`);
 	}
 	const { state, config } = result;
-	const enabledStr = state.enabled ? "enabled" : "disabled";
-	const phaseStr = state.current.toUpperCase();
-	const redBlk = config.blockedInRed.join(", ") || "(none)";
-	const greenBlk = config.blockedInGreen.join(", ") || "(none)";
-	const commands = config.testCommands.join(", ") || "(none)";
+	const info = getStatusInfo(state, config);
 
 	deps.tddLog(tddDir, "INFO", "tdd_status: queried", {
 		enabled: state.enabled,
@@ -305,17 +269,7 @@ export async function executeTddStatus(
 	});
 
 	return {
-		content: [
-			{
-				type: "text",
-				text:
-					`\nTDD enforcer ${enabledStr}\n` +
-					`Current phase: ${phaseStr}\n` +
-					`Blocked in RED: ${redBlk}\n` +
-					`Blocked in GREEN: ${greenBlk}\n` +
-					`Test commands: ${commands}`,
-			},
-		],
+		content: [{ type: "text", text: `\n${info}` }],
 		details: {
 			enabled: state.enabled,
 			phase: state.current,

package/engine/index.ts

@@ -17,7 +17,12 @@ export {
 	undoLastCommit,
 	untrackedFiles,
 } from "./git.js";
-export { loadPhaseState, savePhaseState } from "./state.js";
+export { tddLog } from "./log.js";
+export type { AdvanceResult } from "./orchestrate.js";
+export { advancePhase, getStatusInfo, revertPhase } from "./orchestrate.js";
+export { getNudgePrompt } from "./prompts.js";
+export type { TddLoadResult } from "./state.js";
+export { loadPhaseState, loadTddState, savePhaseState } from "./state.js";
 export { checkGate, getDisallowedChanges, nextPhase } from "./transition.js";
 export type {
 	Config,

package/engine/log.test.ts

@@ -0,0 +1,171 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { tddLog } from "./log.js";
+
+describe("tddLog", () => {
+	let mockExistsSync: ReturnType<typeof vi.fn>;
+	let mockMkdirSync: ReturnType<typeof vi.fn>;
+	let mockAppendFileSync: ReturnType<typeof vi.fn>;
+	let mockWriteFileSync: ReturnType<typeof vi.fn>;
+	let mockReadFileSync: ReturnType<typeof vi.fn>;
+	let writtenContent: string;
+
+	function makeDeps() {
+		return {
+			existsSync: mockExistsSync,
+			mkdirSync: mockMkdirSync,
+			appendFileSync: mockAppendFileSync,
+			writeFileSync: mockWriteFileSync,
+			readFileSync: mockReadFileSync,
+		};
+	}
+
+	beforeEach(() => {
+		writtenContent = "";
+		mockExistsSync = vi.fn().mockReturnValue(true);
+		mockMkdirSync = vi.fn();
+		mockAppendFileSync = vi.fn((_path: string, content: string) => {
+			writtenContent += content;
+		});
+		mockWriteFileSync = vi.fn((_path: string, content: string) => {
+			writtenContent = content;
+		});
+		mockReadFileSync = vi.fn(() => writtenContent);
+	});
+
+	it("appends log line with timestamp and level", () => {
+		tddLog("/tdd", "INFO", "hello", undefined, makeDeps());
+
+		expect(mockAppendFileSync).toHaveBeenCalledOnce();
+		const written = mockAppendFileSync.mock.calls[0][1] as string;
+		expect(written).toMatch(/^\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
+		expect(written).toContain("[INFO]");
+		expect(written).toContain("hello");
+		expect(written.endsWith("\n")).toBe(true);
+	});
+
+	it("appends multiple lines", () => {
+		tddLog("/tdd", "INFO", "line one", undefined, makeDeps());
+		tddLog("/tdd", "DEBUG", "line two", undefined, makeDeps());
+
+		const lines = writtenContent.trim().split("\n");
+		expect(lines).toHaveLength(2);
+		expect(lines[0]).toContain("[INFO]");
+		expect(lines[0]).toContain("line one");
+		expect(lines[1]).toContain("[DEBUG]");
+		expect(lines[1]).toContain("line two");
+		expect(mockAppendFileSync).toHaveBeenCalledTimes(2);
+	});
+
+	it("includes data as JSON when provided", () => {
+		tddLog("/tdd", "INFO", "with data", { key: "val", num: 42 }, makeDeps());
+
+		expect(writtenContent).toContain('{"key":"val","num":42}');
+	});
+
+	it("includes data after message separated by a space", () => {
+		tddLog("/tdd", "INFO", "msg", { a: 1 }, makeDeps());
+
+		const line = writtenContent.trim();
+		expect(line).toContain('msg {"a":1}');
+	});
+
+	it("trims to last 1000 lines when exceeded", () => {
+		for (let i = 0; i < 1005; i++) {
+			tddLog("/tdd", "DEBUG", `line ${i}`, undefined, makeDeps());
+		}
+
+		const lines = writtenContent.trim().split("\n");
+		expect(lines).toHaveLength(1000);
+		expect(lines[0]).toContain("line 5");
+		expect(lines[999]).toContain("line 1004");
+	});
+
+	it("does not throw when appendFileSync fails", () => {
+		mockAppendFileSync = vi.fn(() => {
+			throw new Error("ENOENT: no such file or directory");
+		});
+
+		expect(() =>
+			tddLog("/nonexistent/path/tdd", "INFO", "fail", undefined, makeDeps()),
+		).not.toThrow();
+	});
+
+	it("does not throw when readFileSync fails (first write)", () => {
+		mockReadFileSync = vi.fn(() => {
+			throw new Error("ENOENT: no such file or directory");
+		});
+
+		expect(() =>
+			tddLog("/tdd", "INFO", "hello", undefined, makeDeps()),
+		).not.toThrow();
+		expect(mockAppendFileSync).toHaveBeenCalled();
+	});
+
+	it("handles undefined data gracefully", () => {
+		tddLog("/tdd", "WARN", "no data", undefined, makeDeps());
+
+		expect(writtenContent).toContain("[WARN]");
+		expect(writtenContent).toContain("no data");
+		expect(writtenContent).not.toContain("{}");
+	});
+
+	it("logs at WARN level", () => {
+		tddLog("/tdd", "WARN", "warning message", undefined, makeDeps());
+		expect(writtenContent).toContain("[WARN]");
+	});
+
+	it("logs at ERROR level", () => {
+		tddLog("/tdd", "ERROR", "error message", undefined, makeDeps());
+		expect(writtenContent).toContain("[ERROR]");
+	});
+
+	it("logs at DEBUG level", () => {
+		tddLog("/tdd", "DEBUG", "debug message", undefined, makeDeps());
+		expect(writtenContent).toContain("[DEBUG]");
+	});
+
+	it("writes to the path join(tddDir, 'tdd.log')", () => {
+		tddLog("/custom/tdd/path", "INFO", "test", undefined, makeDeps());
+
+		expect(mockAppendFileSync).toHaveBeenCalledWith(
+			"/custom/tdd/path/tdd.log",
+			expect.any(String),
+			"utf-8",
+		);
+	});
+
+	it("trims to exactly 1000 lines keeping newest", () => {
+		for (let i = 0; i < 1001; i++) {
+			tddLog("/tdd", "DEBUG", `line ${i}`, undefined, makeDeps());
+		}
+
+		const lines = writtenContent.trim().split("\n");
+		expect(lines).toHaveLength(1000);
+		expect(lines[0]).toContain("line 1");
+		expect(lines[999]).toContain("line 1000");
+	});
+
+	it("keeps all lines when exactly at MAX_LINES", () => {
+		for (let i = 0; i < 1000; i++) {
+			tddLog("/tdd", "DEBUG", `line ${i}`, undefined, makeDeps());
+		}
+
+		const lines = writtenContent.trim().split("\n");
+		expect(lines).toHaveLength(1000);
+		expect(lines[0]).toContain("line 0");
+		expect(lines[999]).toContain("line 999");
+	});
+
+	it("appends to existing content instead of overwriting", () => {
+		tddLog("/tdd", "INFO", "first", undefined, makeDeps());
+		tddLog("/tdd", "INFO", "second", undefined, makeDeps());
+
+		expect(writtenContent).toContain("first");
+		expect(writtenContent).toContain("second");
+	});
+
+	it("uses the real filesystem deps by default", () => {
+		// Just verify the function exists and can be called without deps
+		expect(typeof tddLog).toBe("function");
+	});
+});