tdd-enforcer 0.2.2 → 0.2.5

package/adapters/pi/log.test.ts

@@ -1,73 +1,95 @@
-import { describe, it, expect } from "vitest";
-import { mkdirSync, writeFileSync, rmSync, readFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
+import { describe, it, expect, beforeEach, vi } from "vitest";
 import { tddLog } from "./log.js";
 
-function setup() {
-  const dir = join(tmpdir(), `tdd-log-test-${Date.now()}`);
-  mkdirSync(dir, { recursive: true });
-  return dir;
-}
+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 teardown(dir: string) {
-  rmSync(dir, { recursive: true, force: true });
-}
+  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);
+  });
 
-describe("tddLog", () => {
   it("creates the log file if it doesn't exist", () => {
-    const dir = setup();
-    tddLog(dir, "INFO", "hello");
-    expect(existsSync(join(dir, "tdd.log"))).toBe(true);
-    teardown(dir);
+    // readFileSync throws → outer catch silently swallows it
+    mockReadFileSync = vi.fn(() => {
+      throw new Error("ENOENT: no such file or directory");
+    });
+
+    tddLog("/tdd", "INFO", "hello", undefined, makeDeps());
+
+    expect(mockAppendFileSync).toHaveBeenCalled();
+    expect(mockAppendFileSync.mock.calls[0][1]).toContain("hello");
   });
 
   it("appends multiple lines", () => {
-    const dir = setup();
-    tddLog(dir, "INFO", "line one");
-    tddLog(dir, "DEBUG", "line two");
-    const content = readFileSync(join(dir, "tdd.log"), "utf-8");
-    const lines = content.trim().split("\n");
+    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");
-    teardown(dir);
+    expect(mockAppendFileSync).toHaveBeenCalledTimes(2);
   });
 
   it("includes data as JSON when provided", () => {
-    const dir = setup();
-    tddLog(dir, "INFO", "with data", { key: "val", num: 42 });
-    const content = readFileSync(join(dir, "tdd.log"), "utf-8");
-    expect(content).toContain('{"key":"val","num":42}');
-    teardown(dir);
+    tddLog("/tdd", "INFO", "with data", { key: "val", num: 42 }, makeDeps());
+
+    expect(writtenContent).toContain('{"key":"val","num":42}');
   });
 
   it("trims to last 1000 lines when exceeded", () => {
-    const dir = setup();
     for (let i = 0; i < 1005; i++) {
-      tddLog(dir, "DEBUG", `line ${i}`);
+      tddLog("/tdd", "DEBUG", `line ${i}`, undefined, makeDeps());
     }
-    const content = readFileSync(join(dir, "tdd.log"), "utf-8");
-    const lines = content.trim().split("\n");
+
+    const lines = writtenContent.trim().split("\n");
     expect(lines).toHaveLength(1000);
     expect(lines[0]).toContain("line 5");
     expect(lines[999]).toContain("line 1004");
-    teardown(dir);
   });
 
   it("does not throw on invalid tddDir", () => {
-    expect(() => tddLog("/nonexistent/path/tdd", "INFO", "fail")).not.toThrow();
+    // Simulate appendFileSync failure
+    mockAppendFileSync = vi.fn(() => {
+      throw new Error("ENOENT: no such file or directory");
+    });
+
+    expect(() =>
+      tddLog("/nonexistent/path/tdd", "INFO", "fail", undefined, makeDeps()),
+    ).not.toThrow();
   });
 
   it("handles missing data field gracefully", () => {
-    const dir = setup();
-    tddLog(dir, "WARN", "no data");
-    const content = readFileSync(join(dir, "tdd.log"), "utf-8");
-    expect(content).toContain("[WARN]");
-    expect(content).toContain("no data");
-    expect(content).not.toContain("{}");
-    teardown(dir);
+    tddLog("/tdd", "WARN", "no data", undefined, makeDeps());
+
+    expect(writtenContent).toContain("[WARN]");
+    expect(writtenContent).toContain("no data");
+    expect(writtenContent).not.toContain("{}");
   });
 });

package/adapters/pi/log.ts

@@ -1,13 +1,22 @@
-import { appendFileSync, readFileSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
 const MAX_LINES = 1000;
 
+type FsDeps = {
+  existsSync: typeof existsSync;
+  mkdirSync: typeof mkdirSync;
+  appendFileSync: typeof appendFileSync;
+  writeFileSync: typeof writeFileSync;
+  readFileSync: typeof readFileSync;
+};
+
 export function tddLog(
   tddDir: string,
   level: "INFO" | "WARN" | "ERROR" | "DEBUG",
   msg: string,
   data?: Record<string, unknown>,
+  deps: FsDeps = { existsSync, mkdirSync, appendFileSync, writeFileSync, readFileSync },
 ): void {
   try {
     const logPath = join(tddDir, "tdd.log");
@@ -15,14 +24,14 @@ export function tddLog(
     const dataStr = data !== undefined ? ` ${JSON.stringify(data)}` : "";
     const line = `[${timestamp}] [${level}] ${msg}${dataStr}\n`;
 
-    appendFileSync(logPath, line, "utf-8");
+    deps.appendFileSync(logPath, line, "utf-8");
 
     // Trim to last MAX_LINES
-    const content = readFileSync(logPath, "utf-8");
+    const content = deps.readFileSync(logPath, "utf-8");
     const lines = content.trimEnd().split("\n");
     if (lines.length > MAX_LINES) {
       const trimmed = lines.slice(-MAX_LINES).join("\n") + "\n";
-      writeFileSync(logPath, trimmed, "utf-8");
+      deps.writeFileSync(logPath, trimmed, "utf-8");
     }
   } catch {
     // Logging never throws — fail silently

package/adapters/pi/prompts.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "vitest";
+import { getNudgePrompt } from "./prompts.js";
+import type { Config } from "../../engine/types.js";
+
+const config: Config = {
+  blockedInRed: ["tests/**/*.test.ts"],
+  blockedInGreen: ["src/**/*.ts"],
+  testCommands: ["npm test"],
+  timeoutSeconds: 30,
+};
+
+describe("getNudgePrompt", () => {
+  it("returns RED prompt with blocked files", () => {
+    const result = getNudgePrompt("red", config);
+    expect(result).toContain("RED");
+    expect(result).toContain("Blocked files: tests/**/*.test.ts");
+  });
+
+  it("returns GREEN prompt with blocked files", () => {
+    const result = getNudgePrompt("green", config);
+    expect(result).toContain("GREEN");
+    expect(result).toContain("Blocked files: src/**/*.ts");
+  });
+
+  it("returns REFACTOR prompt", () => {
+    const result = getNudgePrompt("refactor", config);
+    expect(result).toContain("REFACTOR");
+    expect(result).toContain("free to modify");
+  });
+
+  it("returns empty string for unknown phase", () => {
+    const result = getNudgePrompt("blurple" as any, config);
+    expect(result).toBe("");
+  });
+});

package/adapters/pi/prompts.ts

@@ -1,24 +1,25 @@
 import type { Phase, Config } from "../../engine/types.js";
 
-export function getNudgePrompt(phase: Phase, config: Config, matchedFiles?: string[]): string {
-  const redPatterns = (matchedFiles ?? config.allowedRedPhaseFiles).join(", ");
-  const greenPatterns = config.allowedGreenPhaseFiles.join(", ");
+export function getNudgePrompt(phase: Phase, config: Config): string {
+  const redBlock = config.blockedInRed.join(", ");
+  const greenBlock = config.blockedInGreen.join(", ");
 
   switch (phase) {
     case "red":
       return (
-        `You are now in **RED** phase. Write failing tests matching: ${redPatterns}\n` +
-        "Only these files can be modified. Once tests fail, call `next_tdd_phase` to proceed to GREEN.\n" +
-        "Keep this cycle small. Write tests for one feature at a time. " +
-        "Cover happy path, edge cases, and unhappy paths before advancing to GREEN."
+        `You are now in **RED** phase. Write failing tests.\n` +
+        `Blocked files: ${redBlock}\n` +
+        "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. Keep cycles small so reverting is cheap."
       );
     case "green":
       return (
-        `You are now in **GREEN** phase. Test files (${redPatterns}) are locked.\n` +
-        `Implement features matching: ${greenPatterns}\n` +
-        "Call `next_tdd_phase` to proceed to REFACTOR.\n" +
-        "If the RED phase tests were wrong, call `previous_tdd_phase` to go back and fix them. " +
-        "Don't be afraid to discard — clean slate beats patched code."
+        `You are now in **GREEN** phase. Implement features.\n` +
+        `Blocked files: ${greenBlock}\n` +
+        "All other files are free to modify. Call `next_tdd_phase` to proceed to REFACTOR.\n" +
+        "Write minimal code to make the failing tests pass — nothing more.\n" +
+        "If the RED phase tests were wrong, call `previous_tdd_phase` to go back and fix them."
       );
     case "refactor":
       return (

package/adapters/pi/tools.test.ts

@@ -0,0 +1,351 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { executeNextPhase, executePreviousPhase, executeTddStatus } from "./tools.js";
+import type { NextPhaseDeps, PreviousPhaseDeps, TddStatusDeps } from "./tools.js";
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+const CONFIG = {
+  blockedInRed: ["tests/**/*.test.ts"],
+  blockedInGreen: ["src/**/*.ts"],
+  testCommands: ["npm test"],
+  timeoutSeconds: 30,
+};
+
+// ── executeNextPhase ────────────────────────────────────────────────────────
+
+describe("executeNextPhase", () => {
+  let mockLoadTddState: ReturnType<typeof vi.fn>;
+  let mockNextPhase: ReturnType<typeof vi.fn>;
+  let mockGetDisallowedChanges: ReturnType<typeof vi.fn>;
+  let mockCheckGate: ReturnType<typeof vi.fn>;
+  let mockSnapshot: ReturnType<typeof vi.fn>;
+  let mockSavePhaseState: ReturnType<typeof vi.fn>;
+  let mockGetNudgePrompt: ReturnType<typeof vi.fn>;
+  let mockAsyncExec: ReturnType<typeof vi.fn>;
+  let mockTddLog: ReturnType<typeof vi.fn>;
+
+  function makeDeps(overrides: Partial<NextPhaseDeps> = {}): NextPhaseDeps {
+    return {
+      loadTddState: mockLoadTddState,
+      nextPhase: mockNextPhase,
+      getDisallowedChanges: mockGetDisallowedChanges,
+      checkGate: mockCheckGate,
+      snapshot: mockSnapshot,
+      savePhaseState: mockSavePhaseState,
+      getNudgePrompt: mockGetNudgePrompt,
+      asyncExec: mockAsyncExec,
+      tddLog: mockTddLog,
+      ...overrides,
+    };
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockLoadTddState = vi.fn();
+    mockNextPhase = vi.fn();
+    mockGetDisallowedChanges = vi.fn().mockReturnValue([]);
+    mockCheckGate = vi.fn();
+    mockSnapshot = vi.fn().mockReturnValue("hash123");
+    mockSavePhaseState = vi.fn();
+    mockGetNudgePrompt = vi.fn().mockReturnValue("");
+    mockAsyncExec = vi.fn();
+    mockTddLog = vi.fn();
+
+    mockNextPhase.mockImplementation((p: string) =>
+      p === "red" ? "green" : p === "green" ? "refactor" : p === "refactor" ? "red" : null,
+    );
+    mockCheckGate.mockResolvedValue({ passed: true, message: "ok" });
+    mockAsyncExec.mockResolvedValue({ stdout: "", stderr: "" });
+  });
+
+  it("returns config error when TDD not setup", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: false,
+      reason: "Missing .pi/tdd/ directory. See the tdd-enforcer skill to learn how to set up TDD configs.",
+    });
+    const result = await executeNextPhase({ cwd: "/test" } as any, makeDeps());
+    expect(result.content[0].text).toContain("Missing .pi/tdd/");
+  });
+
+  it("returns disabled message when TDD disabled", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: false, current: "red" },
+      config: CONFIG,
+    });
+    const result = await executeNextPhase({ cwd: "/test" } as any, makeDeps());
+    expect(result.content[0].text).toContain("not enabled");
+  });
+
+  it("blocks when allowlist violations exist", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: true, current: "red" },
+      config: CONFIG,
+    });
+    mockGetDisallowedChanges.mockReturnValue(["src/violation.ts"]);
+    const result = await executeNextPhase({ cwd: "/test" } as any, makeDeps());
+    expect(result.content[0].text).toContain("BLOCKED");
+    expect(result.content[0].text).toContain("src/violation.ts");
+  });
+
+  it("blocks red→green when tests pass (need failing test)", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: true, current: "red" },
+      config: CONFIG,
+    });
+    mockCheckGate.mockResolvedValue({
+      passed: false,
+      message: "Tests passed. Add a failing test before transitioning to GREEN.",
+    });
+    const result = await executeNextPhase({ cwd: "/test" } as any, makeDeps());
+    expect(result.content[0].text).toContain("Add a failing test");
+    expect(result.content[0].text).toContain("GREEN");
+  });
+
+  it("blocks green→refactor when tests fail", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: true, current: "green" },
+      config: CONFIG,
+    });
+    mockCheckGate.mockResolvedValue({
+      passed: false,
+      message: "Tests failed. Fix them before transitioning to REFACTOR.",
+    });
+    const result = await executeNextPhase({ cwd: "/test" } as any, makeDeps());
+    expect(result.content[0].text).toContain("failed");
+    expect(result.content[0].text).toContain("REFACTOR");
+  });
+
+  it("advances red→green when tests fail", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: true, current: "red" },
+      config: CONFIG,
+    });
+    mockCheckGate.mockResolvedValue({ passed: true, message: "Tests fail — proceed to GREEN." });
+    mockGetNudgePrompt.mockReturnValue("You are now in **GREEN** phase.");
+    const result = await executeNextPhase({ cwd: "/test" } as any, makeDeps());
+    expect(result.content[0].text).toContain("GREEN");
+    expect(mockSnapshot).toHaveBeenCalledWith("/test", "red");
+    expect(mockSavePhaseState).toHaveBeenCalledWith("/test", { enabled: true, current: "green" });
+  });
+
+  it("advances green→refactor when tests pass", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: true, current: "green" },
+      config: CONFIG,
+    });
+    mockCheckGate.mockResolvedValue({ passed: true, message: "All tests pass — proceeding." });
+    mockGetNudgePrompt.mockReturnValue("You are now in **REFACTOR** phase.");
+    const result = await executeNextPhase({ cwd: "/test" } as any, makeDeps());
+    expect(result.content[0].text).toContain("REFACTOR");
+    expect(mockSnapshot).toHaveBeenCalledWith("/test", "green");
+    expect(mockSavePhaseState).toHaveBeenCalledWith("/test", { enabled: true, current: "refactor" });
+  });
+
+  it("blocks refactor→red when tests fail", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: true, current: "refactor" },
+      config: CONFIG,
+    });
+    mockCheckGate.mockResolvedValue({
+      passed: false,
+      message: "Tests failed. Fix them before transitioning to RED.",
+    });
+    const result = await executeNextPhase({ cwd: "/test" } as any, makeDeps());
+    expect(result.content[0].text).toContain("failed");
+    expect(result.content[0].text).toContain("RED");
+    expect(mockSavePhaseState).not.toHaveBeenCalled();
+  });
+
+  it("advances refactor→red when tests pass", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: true, current: "refactor" },
+      config: CONFIG,
+    });
+    mockCheckGate.mockResolvedValue({ passed: true, message: "All tests pass — proceeding." });
+    mockGetNudgePrompt.mockReturnValue("You are now in **RED** phase.");
+    const result = await executeNextPhase({ cwd: "/test" } as any, makeDeps());
+    expect(result.content[0].text).toContain("RED");
+    expect(mockSnapshot).toHaveBeenCalledWith("/test", "refactor");
+    expect(mockSavePhaseState).toHaveBeenCalledWith("/test", { enabled: true, current: "red" });
+  });
+});
+
+// ── executePreviousPhase ────────────────────────────────────────────────────
+
+describe("executePreviousPhase", () => {
+  let mockLoadTddState: ReturnType<typeof vi.fn>;
+  let mockHasParent: ReturnType<typeof vi.fn>;
+  let mockHeadMessage: ReturnType<typeof vi.fn>;
+  let mockResetHard: ReturnType<typeof vi.fn>;
+  let mockUndoLastCommit: ReturnType<typeof vi.fn>;
+  let mockSavePhaseState: ReturnType<typeof vi.fn>;
+  let mockTddLog: ReturnType<typeof vi.fn>;
+
+  function makeDeps(overrides: Partial<PreviousPhaseDeps> = {}): PreviousPhaseDeps {
+    return {
+      loadTddState: mockLoadTddState,
+      hasParent: mockHasParent,
+      headMessage: mockHeadMessage,
+      resetHard: mockResetHard,
+      undoLastCommit: mockUndoLastCommit,
+      savePhaseState: mockSavePhaseState,
+      tddLog: mockTddLog,
+      ...overrides,
+    };
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockLoadTddState = vi.fn();
+    mockHasParent = vi.fn();
+    mockHeadMessage = vi.fn();
+    mockResetHard = vi.fn();
+    mockUndoLastCommit = vi.fn();
+    mockSavePhaseState = vi.fn();
+    mockTddLog = vi.fn();
+
+    mockHasParent.mockReturnValue(true);
+  });
+
+  it("returns config error when TDD not setup", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: false,
+      reason: "Missing .pi/tdd/ directory.",
+    });
+    const result = await executePreviousPhase({ cwd: "/test" } as any, makeDeps());
+    expect(result.content[0].text).toContain("Missing .pi/tdd/");
+  });
+
+  it("returns disabled message when TDD disabled", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: false, current: "red" },
+      config: CONFIG,
+    });
+    const result = await executePreviousPhase({ cwd: "/test" } as any, makeDeps());
+    expect(result.content[0].text).toContain("not enabled");
+  });
+
+  it("returns no-parent message when only init commit exists", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: true, current: "red" },
+      config: CONFIG,
+    });
+    mockHasParent.mockReturnValue(false);
+    const result = await executePreviousPhase({ cwd: "/test" } as any, makeDeps());
+    expect(result.content[0].text).toContain("No previous phase");
+  });
+
+  it("returns error when HEAD message is not a TDD snapshot", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: true, current: "red" },
+      config: CONFIG,
+    });
+    mockHeadMessage.mockReturnValue("garbage");
+    const result = await executePreviousPhase({ cwd: "/test" } as any, makeDeps());
+    expect(result.content[0].text).toContain("not a TDD snapshot");
+  });
+
+  it("reverts to previous phase on success", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: true, current: "green" },
+      config: CONFIG,
+    });
+    mockHeadMessage.mockReturnValue("tdd: red");
+    const result = await executePreviousPhase({ cwd: "/test" } as any, makeDeps());
+    expect(result.content[0].text).toContain("RED");
+    expect(mockResetHard).toHaveBeenCalledWith("/test");
+    expect(mockUndoLastCommit).toHaveBeenCalledWith("/test");
+    expect(mockSavePhaseState).toHaveBeenCalledWith("/test", { enabled: true, current: "red" });
+  });
+
+  it("reverts to correct phase from green head label", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: true, current: "refactor" },
+      config: CONFIG,
+    });
+    mockHeadMessage.mockReturnValue("tdd: green");
+    const result = await executePreviousPhase({ cwd: "/test" } as any, makeDeps());
+    expect(result.content[0].text).toContain("GREEN");
+    expect(mockSavePhaseState).toHaveBeenCalledWith("/test", { enabled: true, current: "green" });
+  });
+});
+
+// ── executeTddStatus ────────────────────────────────────────────────────────
+
+describe("executeTddStatus", () => {
+  let mockLoadTddState: ReturnType<typeof vi.fn>;
+  let mockTddLog: ReturnType<typeof vi.fn>;
+
+  function makeDeps(overrides: Partial<TddStatusDeps> = {}): TddStatusDeps {
+    return {
+      loadTddState: mockLoadTddState,
+      tddLog: mockTddLog,
+      ...overrides,
+    };
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockLoadTddState = vi.fn();
+    mockTddLog = vi.fn();
+  });
+
+  it("returns config error when TDD not setup", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: false,
+      reason: "Missing .pi/tdd/ directory.",
+    });
+    const result = await executeTddStatus({ cwd: "/test" } as any, makeDeps());
+    expect(result.content[0].text).toContain("Missing .pi/tdd/");
+  });
+
+  it("returns disabled message when TDD disabled", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: false, current: "red" },
+      config: CONFIG,
+    });
+    const result = await executeTddStatus({ cwd: "/test" } as any, makeDeps());
+    expect(result.content[0].text).toContain("not enabled");
+  });
+
+  it("returns status details when TDD enabled", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: true, current: "red" },
+      config: CONFIG,
+    });
+    const result = await executeTddStatus({ cwd: "/test" } as any, makeDeps());
+    expect(result.content[0].text).toContain("enabled");
+    expect(result.content[0].text).toContain("RED");
+    expect(result.content[0].text).toContain("tests/**/*.test.ts");
+    expect(result.content[0].text).toContain("src/**/*.ts");
+    expect(result.details).toBeDefined();
+    expect(result.details!.enabled).toBe(true);
+    expect(result.details!.phase).toBe("red");
+  });
+
+  it("returns status with current phase", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: true, current: "green" },
+      config: CONFIG,
+    });
+    const result = await executeTddStatus({ cwd: "/test" } as any, makeDeps());
+    expect(result.content[0].text).toContain("GREEN");
+    expect(result.details!.phase).toBe("green");
+  });
+});