tdd-enforcer 0.3.2 → 0.3.4

package/engine/state.test.ts

@@ -1,8 +1,8 @@
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { describe, expect, it } from "vitest";
-import { loadPhaseState, savePhaseState } from "./state.js";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { loadPhaseState, loadTddState, savePhaseState } from "./state.js";
 
 function withTempDir(fn: (dir: string) => void) {
 	const dir = join(tmpdir(), `tdd-state-test-${Date.now()}`);
@@ -82,3 +82,275 @@ describe("savePhaseState", () => {
 		});
 	});
 });
+
+// ── loadTddState ────────────────────────────────────────────────────────────
+
+const validRules = {
+	blockedInRed: ["tests/**/*.test.ts"],
+	blockedInGreen: ["src/**/*.ts"],
+	testCommands: ["npm test"],
+	timeoutSeconds: 30,
+};
+
+const validPhase = {
+	enabled: true,
+	current: "red",
+};
+
+describe("loadTddState", () => {
+	let mockExistsSync: ReturnType<typeof vi.fn>;
+	let mockLoadConfig: ReturnType<typeof vi.fn>;
+	let mockInitGit: ReturnType<typeof vi.fn>;
+	let mockLoadPhaseState: ReturnType<typeof vi.fn>;
+	let mockSavePhaseState: ReturnType<typeof vi.fn>;
+	let mockHeadMessage: ReturnType<typeof vi.fn>;
+	let mockNextPhase: ReturnType<typeof vi.fn>;
+	let mockStageFiles: ReturnType<typeof vi.fn>;
+
+	const realNextPhase = (p: string) =>
+		p === "red"
+			? "green"
+			: p === "green"
+				? "refactor"
+				: p === "refactor"
+					? "red"
+					: null;
+
+	function makeDeps(overrides = {}) {
+		return {
+			existsSync: mockExistsSync,
+			loadConfig: mockLoadConfig,
+			initGit: mockInitGit,
+			loadPhaseState: mockLoadPhaseState,
+			savePhaseState: mockSavePhaseState,
+			headMessage: mockHeadMessage,
+			nextPhase: mockNextPhase,
+			stageFiles: mockStageFiles,
+			...overrides,
+		};
+	}
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		mockExistsSync = vi.fn().mockImplementation((path: string) => {
+			if (path.includes(".git")) return false;
+			if (path.includes(".pi/tdd")) return true;
+			return true;
+		});
+		mockLoadConfig = vi.fn().mockReturnValue(validRules);
+		mockInitGit = vi.fn();
+		mockLoadPhaseState = vi.fn().mockReturnValue(validPhase);
+		mockSavePhaseState = vi.fn();
+		mockHeadMessage = vi.fn().mockReturnValue("tdd: red");
+		mockNextPhase = vi.fn().mockImplementation(realNextPhase);
+		mockStageFiles = vi.fn();
+	});
+
+	it("returns missing dir error when .pi/tdd does not exist", () => {
+		mockExistsSync.mockReturnValue(false);
+		const result = loadTddState("/test", makeDeps());
+		expect(result.ok).toBe(false);
+		expect(result.reason).toContain("Missing .pi/tdd/");
+	});
+
+	it("returns missing rules.json error when only dir exists", () => {
+		mockExistsSync.mockImplementation((path: string) => {
+			if (path.includes("rules.json")) return false;
+			if (path.includes(".pi/tdd")) return true;
+			return false;
+		});
+		const result = loadTddState("/test", makeDeps());
+		expect(result.ok).toBe(false);
+		expect(result.reason).toContain("rules.json");
+	});
+
+	it("auto-creates state.json when missing (default RED disabled)", () => {
+		mockExistsSync.mockImplementation((path: string) => {
+			if (path.includes("state.json")) return false;
+			if (path.includes(".git")) return false;
+			return true;
+		});
+		mockHeadMessage.mockReturnValue("tdd: init");
+		const result = loadTddState("/test", makeDeps());
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.state.enabled).toBe(false);
+			expect(result.state.current).toBe("red");
+		}
+		expect(mockInitGit).toHaveBeenCalled();
+		expect(mockSavePhaseState).toHaveBeenCalledWith("/test", {
+			enabled: false,
+			current: "red",
+		});
+	});
+
+	it("auto-creates state.json when corrupted (recovers to default)", () => {
+		mockExistsSync.mockImplementation((path: string) => {
+			if (path.includes("state.json")) return true;
+			if (path.includes(".git")) return false;
+			return true;
+		});
+		mockLoadPhaseState.mockImplementation(() => {
+			throw new Error("corrupt");
+		});
+		mockHeadMessage.mockReturnValue("tdd: init");
+		const result = loadTddState("/test", makeDeps());
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.state.enabled).toBe(false);
+			expect(result.state.current).toBe("red");
+		}
+	});
+
+	it("returns invalid rules.json error for malformed JSON", () => {
+		mockLoadConfig.mockImplementation(() => {
+			throw new Error("Unexpected token");
+		});
+		const result = loadTddState("/test", makeDeps());
+		expect(result.ok).toBe(false);
+		expect(result.reason).toContain("Invalid .pi/tdd/rules.json");
+	});
+
+	it("returns ok when state.json has enabled: false (callers check enabled)", () => {
+		mockLoadPhaseState.mockReturnValue({ enabled: false, current: "red" });
+		const result = loadTddState("/test", makeDeps());
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.state.enabled).toBe(false);
+			expect(result.state.current).toBe("red");
+		}
+	});
+
+	it("returns ok with state and config when everything valid", () => {
+		mockLoadPhaseState.mockReturnValue(validPhase);
+		const result = loadTddState("/test", makeDeps());
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.state.current).toBe("red");
+			expect(result.state.enabled).toBe(true);
+			expect(result.config.testCommands).toEqual(["npm test"]);
+			expect(result.config.blockedInRed).toEqual(["tests/**/*.test.ts"]);
+		}
+	});
+
+	it("auto-creates git repo when missing", () => {
+		let gitExists = false;
+		mockExistsSync.mockImplementation((path: string) => {
+			if (path.includes(".git")) return gitExists;
+			if (path.includes(".pi/tdd")) return true;
+			return true;
+		});
+		mockInitGit.mockImplementation(() => {
+			gitExists = true;
+		});
+		const result = loadTddState("/test", makeDeps());
+		expect(result.ok).toBe(true);
+		expect(mockInitGit).toHaveBeenCalled();
+	});
+
+	it("handles multiple calls without error", () => {
+		const r1 = loadTddState("/test", makeDeps());
+		expect(r1.ok).toBe(true);
+		const r2 = loadTddState("/test", makeDeps());
+		expect(r2.ok).toBe(true);
+		expect(mockLoadConfig).toHaveBeenCalledTimes(2);
+	});
+
+	it("recovers from invalid current phase in state.json (auto-creates default)", () => {
+		mockLoadPhaseState.mockImplementation(() => {
+			throw new Error("invalid phase");
+		});
+		mockHeadMessage.mockReturnValue("tdd: init");
+		const result = loadTddState("/test", makeDeps());
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.state.enabled).toBe(false);
+			expect(result.state.current).toBe("red");
+		}
+	});
+
+	it("recoverState: HEAD tdd:red → enabled green", () => {
+		mockExistsSync.mockImplementation((path: string) => {
+			if (path.includes("state.json")) return false;
+			return true;
+		});
+		mockHeadMessage.mockReturnValue("tdd: red");
+		mockNextPhase.mockImplementation(realNextPhase);
+		const result = loadTddState("/test", makeDeps());
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.state.enabled).toBe(true);
+			expect(result.state.current).toBe("green");
+		}
+	});
+
+	it("recoverState: HEAD tdd:green → enabled refactor", () => {
+		mockExistsSync.mockImplementation((path: string) => {
+			if (path.includes("state.json")) return false;
+			return true;
+		});
+		mockHeadMessage.mockReturnValue("tdd: green");
+		const result = loadTddState("/test", makeDeps());
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.state.enabled).toBe(true);
+			expect(result.state.current).toBe("refactor");
+		}
+	});
+
+	it("recoverState: HEAD tdd:refactor → enabled red", () => {
+		mockExistsSync.mockImplementation((path: string) => {
+			if (path.includes("state.json")) return false;
+			return true;
+		});
+		mockHeadMessage.mockReturnValue("tdd: refactor");
+		const result = loadTddState("/test", makeDeps());
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.state.enabled).toBe(true);
+			expect(result.state.current).toBe("red");
+		}
+	});
+
+	it("force-adds state.json after creating it from recovery", () => {
+		mockExistsSync.mockImplementation((path: string) => {
+			if (path.includes("state.json")) return false;
+			if (path.includes(".git")) return false;
+			return true;
+		});
+		mockHeadMessage.mockReturnValue("tdd: init");
+		const result = loadTddState("/test", makeDeps());
+		expect(result.ok).toBe(true);
+		expect(mockStageFiles).toHaveBeenCalledWith("/test", [
+			".pi/tdd/state.json",
+		]);
+	});
+
+	it("does not force-add state.json when it already exists and is valid", () => {
+		mockExistsSync.mockImplementation((path: string) => {
+			if (path.includes("state.json")) return true;
+			if (path.includes(".git")) return true;
+			return true;
+		});
+		const result = loadTddState("/test", makeDeps());
+		expect(result.ok).toBe(true);
+		expect(mockStageFiles).not.toHaveBeenCalled();
+	});
+
+	it("force-adds state.json after recovering from corrupted state", () => {
+		mockExistsSync.mockImplementation((path: string) => {
+			if (path.includes("state.json")) return true;
+			if (path.includes(".git")) return true;
+			return true;
+		});
+		mockLoadPhaseState.mockImplementation(() => {
+			throw new Error("corrupt");
+		});
+		mockHeadMessage.mockReturnValue("tdd: init");
+		const result = loadTddState("/test", makeDeps());
+		expect(result.ok).toBe(true);
+		expect(mockStageFiles).toHaveBeenCalledWith("/test", [
+			".pi/tdd/state.json",
+		]);
+	});
+});

package/engine/state.ts

@@ -1,10 +1,17 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import type { PhaseState } from "./types.js";
+import { loadConfig } from "./config.js";
+import { headMessage, initGit, stageFiles } from "./git.js";
+import { nextPhase } from "./transition.js";
+import type { Config, PhaseState } from "./types.js";
 
 const TDD_DIR = ".pi/tdd";
 const VALID_PHASES = new Set(["red", "green", "refactor"]);
 
+export type TddLoadResult =
+	| { ok: true; state: PhaseState; config: Config }
+	| { ok: false; reason: string };
+
 export function phaseStatePath(projectRoot: string): string {
 	return join(projectRoot, TDD_DIR, "state.json");
 }
@@ -38,3 +45,130 @@ export function savePhaseState(projectRoot: string, state: PhaseState): void {
 	ensureDir(path);
 	writeFileSync(path, JSON.stringify(state, null, 2), "utf-8");
 }
+
+/**
+ * Recover state.json from private git HEAD, or create default.
+ * Returns the state (does not save to disk — caller does that).
+ */
+function recoverState(
+	root: string,
+	tddDir: string,
+	deps: {
+		existsSync: typeof existsSync;
+		headMessage: typeof headMessage;
+		nextPhase: typeof nextPhase;
+	} = { existsSync, headMessage, nextPhase },
+): PhaseState {
+	const gitDir = join(tddDir, ".git");
+	if (deps.existsSync(gitDir)) {
+		try {
+			const msg = deps.headMessage(root);
+			const m = msg.match(/^tdd: (red|green|refactor|init)$/);
+			if (m) {
+				const label = m[1];
+				if (label === "init") {
+					return { enabled: false, current: "red" };
+				}
+				const next = deps.nextPhase(label);
+				return { enabled: true, current: next ?? "red" };
+			}
+		} catch {
+			// No commits or bad HEAD — fall through to default
+		}
+	}
+	return { enabled: false, current: "red" };
+}
+
+/**
+ * Load TDD state + config in one go.
+ * Auto-creates state.json from private git HEAD when missing or corrupted.
+ * Returns ok:true with state and config when rules.json is valid.
+ * Returns ok:false with a specific reason string otherwise.
+ *
+ * Callers must check state.enabled themselves if they need active enforcement.
+ */
+export function loadTddState(
+	root: string,
+	deps: {
+		existsSync: typeof existsSync;
+		loadConfig: typeof loadConfig;
+		initGit: typeof initGit;
+		loadPhaseState: typeof loadPhaseState;
+		savePhaseState: typeof savePhaseState;
+		headMessage: typeof headMessage;
+		nextPhase: typeof nextPhase;
+		stageFiles: typeof stageFiles;
+	} = {
+		existsSync,
+		loadConfig,
+		initGit,
+		loadPhaseState,
+		savePhaseState,
+		headMessage,
+		nextPhase,
+		stageFiles,
+	},
+): TddLoadResult {
+	const tddDir = join(root, ".pi", "tdd");
+	if (!deps.existsSync(tddDir)) {
+		return {
+			ok: false,
+			reason:
+				"Missing .pi/tdd/ directory. See the tdd-enforcer skill to learn how to set up TDD configs.",
+		};
+	}
+
+	const rulesPath = join(tddDir, "rules.json");
+	if (!deps.existsSync(rulesPath)) {
+		return {
+			ok: false,
+			reason:
+				"Missing .pi/tdd/rules.json. See the tdd-enforcer skill to learn how to set up TDD configs.",
+		};
+	}
+
+	let config: Config;
+	try {
+		config = deps.loadConfig(root);
+	} catch (e) {
+		return {
+			ok: false,
+			reason: `Invalid .pi/tdd/rules.json: ${(e as Error).message}. See the tdd-enforcer skill.`,
+		};
+	}
+
+	// Init git if missing — required for state recovery and all consumers
+	const gitDir = join(tddDir, ".git");
+	if (!deps.existsSync(gitDir)) {
+		try {
+			deps.initGit(root);
+		} catch (e) {
+			return {
+				ok: false,
+				reason: `Failed to initialise private git repo: ${(e as Error).message}`,
+			};
+		}
+	}
+
+	// Auto-create state.json if missing or corrupted
+	const phasePath = join(tddDir, "state.json");
+	let state: PhaseState | undefined;
+	if (deps.existsSync(phasePath)) {
+		try {
+			state = deps.loadPhaseState(root);
+		} catch {
+			// Corrupted — recover below
+		}
+	}
+	if (!state) {
+		state = recoverState(root, tddDir, {
+			existsSync: deps.existsSync,
+			headMessage: deps.headMessage,
+			nextPhase: deps.nextPhase,
+		});
+		deps.savePhaseState(root, state);
+		deps.stageFiles(root, [".pi/tdd/state.json"]);
+	}
+
+	return { ok: true, state, config };
+}

package/package.json

@@ -1,9 +1,8 @@
 {
 	"name": "tdd-enforcer",
-	"version": "0.3.2",
+	"version": "0.3.4",
 	"type": "module",
 	"scripts": {
-		"fmt": "biome format --write .",
 		"lint": "biome check .",
 		"lint:fix": "biome check --write .",
 		"test": "vitest run"

package/skills/tdd-enforcer/SKILL.md

@@ -42,8 +42,10 @@ It locks files per phase — only test files in RED, only implementation files i
 - `blockedInRed` — globs the agent **cannot** modify in RED phase (implementation files)
 - `blockedInGreen` — globs the agent **cannot** modify in GREEN phase (test files)
 - `!` exclusion prefix — optional, carves out subsets from a block list at init time. E.g. `!src/**/*.test.ts` excludes co-located test files from `blockedInRed` so the agent can write them in RED phase
-- `testCommands` — shell commands to run tests. **Runs sequentially** — each entry is started one after another. Use `&&` inside a single string entry to chain multiple commands in one step (e.g. `"npm run build && npm test"`). Do not rely on array ordering for dependency chains; put dependent commands in the same string entry with `&&`.
-- `timeoutSeconds` — test timeout per command
+- `testCommands` — determines if a phase transition passes. Exit 0 passes, non-zero blocks. **Runs in parallel** — all entries are started concurrently. Use `&&` inside a single string entry to chain multiple commands in one step (e.g. `"npm run build && npm test"`). Do not rely on array ordering for dependency chains; put dependent commands in the same string entry with `&&`.
+
+  **Prefer auto-fix commands** that apply fixes (formatting, linting, etc.) before reporting remaining violations. Without auto-fix, formatting or lint issues in phase-locked files (e.g. test files in GREEN) will block the gate with no way to fix them — forcing `previous_tdd_phase` and losing all progress. Auto-fix commands avoid this deadlock by fixing locked files before the check runs.
+- `timeoutSeconds` — test timeout per command (default: 120)
 
 2. **User** runs `/tdd:on` to enable enforcement.
 

package/DESIGN.md

@@ -1,183 +0,0 @@
-# TDD Enforcer — pi Extension Design
-
-## Concept
-
-A pi extension that enforces the Red-Green-Refactor TDD cycle by:
-- Tracking current phase (RED / GREEN / REFACTOR)
-- Restricting which files the agent can modify per phase
-- Running tests on phase transitions to enforce red/green gate
-- Nudging the agent with phase-appropriate prompts
-
-## Tools
-
-### `next_tdd_phase`
-
-Advances the cycle:
-
-```
-RED ──(tests fail)──► GREEN ──(tests pass)──► REFACTOR ──(tests pass)──► RED
-```
-
-### `previous_tdd_phase`
-
-Reverts to the previous snapshot by parsing the phase label from the last git snapshot commit. Restores working tree to exact prior state. No gate checks — just revert. Must have clear warning in the tool schema that this will revert all changes in the current state.
-
----
-
-## Phase Rules
-
-| Phase | `allowedRedPhaseFiles` | `allowedGreenPhaseFiles` | Everything else |
-|-------|----------------------|------------------------|-----------------|
-| RED | ✅ Allowed | ❌ Locked | ✅ Free |
-| GREEN | ❌ Locked | ✅ Allowed | ✅ Free |
-| REFACTOR | ✅ Allowed | ✅ Allowed | ✅ Free |
-
-### Transition Gates
-
-- **RED → GREEN**: Tests must **fail**. If tests pass, tool returns error — agent must break a test first.
-- **GREEN → REFACTOR**: Tests must **pass** (all exit codes zero).
-- **REFACTOR → RED**: Tests must **pass** (all exit codes zero).
-
-### Nudging Prompts
-
-Each successful transition returns a message guiding the agent:
-
-- **→ RED**: *"You are now in **RED** phase. Write failing tests matching `allowedRedPhaseFiles` patterns. Only these files can be modified. Once tests fail, call `next_tdd_phase` to proceed to GREEN."* (list matched files)
-- **→ GREEN**: *"You are now in **GREEN** phase. Files matching `allowedRedPhaseFiles` are locked. Implement features in `allowedGreenPhaseFiles` to make tests pass. Call `next_tdd_phase` to proceed to REFACTOR."*
-- **→ REFACTOR**: *"You are now in **REFACTOR** phase. Both `allowedRedPhaseFiles` and `allowedGreenPhaseFiles` are free to modify. Refactor without changing behavior. Call `next_tdd_phase` to start a new RED cycle."*
-
----
-
-## File Enforcement: Private Git + `tool_call` Fast-Feedback
-
-### Source of truth: private git repo
-
-A separate git repository at `.pi/tdd/.git/` that tracks the project root as its working tree. The user's `.git/` is never touched.
-
-```
-.pi/tdd/
-├── .gitignore           # private git — excludes file patterns from snapshots
-├── state.json           # {current: "red", enabled: true}
-├── rules.json           # user config
-└── .git/                # private git — init with --git-dir
-```
-
-**Setup:** `git init` with `--git-dir=.pi/tdd/.git --work-tree=<project-root>`.
-
-**On phase entry (snapshot):**
-`git add -A && git commit -m "tdd: <phase> <ts>"` — captures entire working tree state.
-
-**On `next_tdd_phase` / `previous_tdd_phase` (allowlist check):**
-- `git diff --name-only HEAD` against previous snapshot commit
-- Cross-reference each changed file against phase allowlist
-- Violations → BLOCK with list of disallowed files
-- Also check for untracked files (`git ls-files --others --exclude-standard`)
-
-**On `previous_tdd_phase` (revert):**
-- `git restore --source=<prev-commit> --worktree -- .` — restores project to exact prior snapshot
-- Pop the last snapshot commit in the private git repo
-
-### Benefits of private git
-
-- Catches ALL modifications — write, edit, bash, sed, python, C, anything — because it diffs the working tree, not tool calls
-- Cross-platform (git is everywhere)
-- No shell parsing, no fragile regexes, no edge cases
-- Zero interference with user's git — different `.git/`, no shared refs, no hooks, no global config
-- `.pi/tdd/` is disposable — user can nuke it anytime
-- Free diff, merge, partial restore, binary handling — no custom engine to write
-
-### Fast feedback: per-tool enforcement
-
-The transition-time check catches everything, but it's wasteful to let the agent work on wrong files for a full phase. We enforce per-tool:
-
-#### `write` / `edit` — pre-execution block
-
-The file path is a direct parameter. In `tool_call`:
-- If path is disallowed in current phase → `{ block: true, reason: "..." }`
-- Otherwise → allow
-
-#### `bash` — post-execution detect-and-revert
-
-Bash can modify files indirectly (redirects, `sed -i`, scripts, compilers). Parsing command strings to predict targets is fragile. Instead:
-
-1. **Let bash run** — no pre-check
-2. **In `tool_result`:** `git diff --name-only HEAD` + `git ls-files --others --exclude-standard` to get all changes since phase snapshot
-3. For each file: if it's disallowed in current phase → `git restore <filepath>` and append warning
-
-No in-memory tracking needed. The check is the same for every file regardless of how it was modified — write/edit changes that passed pre-check naturally match the allowed globs, violations get reverted.
-
-#### Why not regex bash parsing?
-
-Everyone else does it (pi-proof, pi-superteam, tdd-guard). It's fragile — misses `$(dynamic paths)`, glob expansion, scripts calling other scripts, piped commands, heredocs with variables. Our git-based post-check catches everything regex misses, with zero false negatives.
-
-Regex pre-check is optional (could catch obvious cases for better UX) but the git post-check is the reliable enforcer.
-
----
-
-### `.gitignore`
-
-The private git's work-tree is the project root, so it respects the project's `.gitignore` automatically — no copy needed, no separate file needed.
-
-If the user wants to exclude additional files from TDD snapshots only, they can create `.pi/tdd/.gitignore` with those patterns. Git checks `.gitignore` starting from the work-tree root, so a file there is picked up naturally.
-
----
-
-## Config: `.pi/tdd/rules.json`
-
-```json
-{
-  "allowedRedPhaseFiles": ["tests/**/*.test.ts", "specs/**/*.spec.ts"],
-  "allowedGreenPhaseFiles": ["src/**/*.ts"],
-  "testCommands": ["npm run test:unit", "npm run test:integration"],
-  "timeoutSeconds": 120
-}
-```
-
-- `allowedRedPhaseFiles`: Glob patterns for files allowed in RED phase (typically test files).
-- `allowedGreenPhaseFiles`: Glob patterns for files allowed in GREEN phase (typically implementation files).
-- Files matching neither set are free in all phases.
-- `testCommands`: `string` (shell-chained with `&&` for sequential) or `string[]` (run in parallel). Must be non-interactive.
-- `timeoutSeconds`: Per-command timeout. Extension passes it as pi's `bash` tool timeout param, so we don't rely on system `timeout` binary.
-
----
-
-
-
----
-
-## Phase State Persistence
-
-Stored in `.pi/tdd/state.json`:
-
-```json
-{
-  "current": "green",
-  "enabled": true
-}
-```
-
-The snapshot history lives in the private git repo's commit log — no explicit stack array needed. `previous_tdd_phase` reads the phase label from the HEAD commit message and restores to the parent. Survives session restarts and extension reloads.
-
----
-
-## Open Questions
-
-### Initial state
-
-How does a project start?
-
-- **Auto RED**: Start in RED unconditionally. If tests already pass, agent sees a warning that there's no failing test yet — it needs to write one or break one.
-- **Auto-detect**: Run tests on startup. If failing → RED. If passing → GREEN (agent is already in the "make it pass" phase).
-- **Prompt**: Ask the user what phase to start in.
-
-### Enabling/disabling
-
-Should we have `/tdd:on` and `/tdd:off` commands to toggle without unloading the extension?
-
-### Config location
-
-Only `.pi/tdd/rules.json` in project root? Or support nested configs?
-
-### Multiple projects / monorepos
-
-If the project root has sub-projects with different test commands, does rules.json support multiple entries keyed by directory?