tdd-enforcer 0.2.3 → 0.2.6

package/adapters/pi/helpers.test.ts

@@ -2,8 +2,8 @@ import { describe, it, expect, beforeEach, vi } from "vitest";
 import { loadTddState } from "./helpers.js";
 
 const validRules = {
-  allowedRedPhaseFiles: ["tests/**/*.test.ts"],
-  allowedGreenPhaseFiles: ["src/**/*.ts"],
+  blockedInRed: ["tests/**/*.test.ts"],
+  blockedInGreen: ["src/**/*.ts"],
   testCommands: ["npm test"],
   timeoutSeconds: 30,
 };
@@ -148,7 +148,7 @@ describe("loadTddState", () => {
       expect(result.state.current).toBe("red");
       expect(result.state.enabled).toBe(true);
       expect(result.config.testCommands).toEqual(["npm test"]);
-      expect(result.config.allowedRedPhaseFiles).toEqual([
+      expect(result.config.blockedInRed).toEqual([
         "tests/**/*.test.ts",
       ]);
     }

package/adapters/pi/hooks.test.ts

@@ -29,8 +29,8 @@ function makeResultDeps(overrides: Record<string, unknown> = {}) {
 }
 
 const VALID_CONFIG = {
-  allowedRedPhaseFiles: ["tests/**/*.test.ts"],
-  allowedGreenPhaseFiles: ["src/**/*.ts"],
+  blockedInRed: ["src/**/*.ts"],
+  blockedInGreen: ["tests/**/*.test.ts"],
   testCommands: ["npm test"],
   timeoutSeconds: 30,
 };

package/adapters/pi/index.test.ts

@@ -2,8 +2,8 @@ import { describe, it, expect, beforeEach, vi } from "vitest";
 import { handleTddOn, handleTddOff, handleTddStatus, handleTddReset } from "./index.js";
 
 const config = {
-  allowedRedPhaseFiles: ["tests/**/*.test.ts"],
-  allowedGreenPhaseFiles: ["src/**/*.ts"],
+  blockedInRed: ["tests/**/*.test.ts"],
+  blockedInGreen: ["src/**/*.ts"],
   testCommands: ["npm test"],
   timeoutSeconds: 30,
 };

package/adapters/pi/index.ts

@@ -119,8 +119,8 @@ export async function handleTddStatus(
   const { state, config } = result;
   const enabledStr = state.enabled ? "enabled" : "disabled";
   const phaseStr = state.current.toUpperCase();
-  const redGlobs = config.allowedRedPhaseFiles.join(", ") || "(none)";
-  const greenGlobs = config.allowedGreenPhaseFiles.join(", ") || "(none)";
+  const redBlk = config.blockedInRed.join(", ") || "(none)";
+  const greenBlk = config.blockedInGreen.join(", ") || "(none)";
   const commands = config.testCommands.join(", ") || "(none)";
 
   deps.tddLog(tddDir, "INFO", "tdd:status: queried", {
@@ -131,8 +131,8 @@ export async function handleTddStatus(
   ctx.ui.notify(
     `TDD enforcer ${enabledStr}\n` +
     `Current phase: ${phaseStr}\n` +
-    `Test files: ${redGlobs}\n` +
-    `Impl files: ${greenGlobs}\n` +
+    `Blocked in RED: ${redBlk}\n` +
+    `Blocked in GREEN: ${greenBlk}\n` +
     `Test commands: ${commands}`,
     "info",
   );

package/adapters/pi/prompts.test.ts

@@ -3,31 +3,23 @@ import { getNudgePrompt } from "./prompts.js";
 import type { Config } from "../../engine/types.js";
 
 const config: Config = {
-  allowedRedPhaseFiles: ["tests/**/*.test.ts"],
-  allowedGreenPhaseFiles: ["src/**/*.ts"],
+  blockedInRed: ["tests/**/*.test.ts"],
+  blockedInGreen: ["src/**/*.ts"],
   testCommands: ["npm test"],
   timeoutSeconds: 30,
 };
 
 describe("getNudgePrompt", () => {
-  it("returns RED prompt with config patterns by default", () => {
+  it("returns RED prompt with blocked files", () => {
     const result = getNudgePrompt("red", config);
     expect(result).toContain("RED");
-    expect(result).toContain("tests/**/*.test.ts");
+    expect(result).toContain("Blocked files: tests/**/*.test.ts");
   });
 
-  it("returns RED prompt with custom matchedFiles override", () => {
-    const result = getNudgePrompt("red", config, ["custom/**/*.test.ts"]);
-    expect(result).toContain("RED");
-    expect(result).toContain("custom/**/*.test.ts");
-    expect(result).not.toContain("tests/**/*.test.ts");
-  });
-
-  it("returns GREEN prompt with both red and green patterns", () => {
+  it("returns GREEN prompt with blocked files", () => {
     const result = getNudgePrompt("green", config);
     expect(result).toContain("GREEN");
-    expect(result).toContain("tests/**/*.test.ts");
-    expect(result).toContain("src/**/*.ts");
+    expect(result).toContain("Blocked files: src/**/*.ts");
   });
 
   it("returns REFACTOR prompt", () => {

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

@@ -5,8 +5,8 @@ import type { NextPhaseDeps, PreviousPhaseDeps, TddStatusDeps } from "./tools.js
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
 const CONFIG = {
-  allowedRedPhaseFiles: ["tests/**/*.test.ts"],
-  allowedGreenPhaseFiles: ["src/**/*.ts"],
+  blockedInRed: ["tests/**/*.test.ts"],
+  blockedInGreen: ["src/**/*.ts"],
   testCommands: ["npm test"],
   timeoutSeconds: 30,
 };

package/adapters/pi/tools.ts

@@ -303,8 +303,8 @@ export async function executeTddStatus(
 
   const { state, config } = result;
   const phaseStr = state.current.toUpperCase();
-  const redGlobs = config.allowedRedPhaseFiles.join(", ") || "(none)";
-  const greenGlobs = config.allowedGreenPhaseFiles.join(", ") || "(none)";
+  const redBlk = config.blockedInRed.join(", ") || "(none)";
+  const greenBlk = config.blockedInGreen.join(", ") || "(none)";
   const commands = config.testCommands.join(", ") || "(none)";
 
   deps.tddLog(tddDir, "INFO", "tdd_status: queried", {
@@ -318,16 +318,16 @@ export async function executeTddStatus(
         text:
           `TDD enforcer enabled\n` +
           `Current phase: ${phaseStr}\n` +
-          `Test files: ${redGlobs}\n` +
-          `Impl files: ${greenGlobs}\n` +
+          `Blocked in RED: ${redBlk}\n` +
+          `Blocked in GREEN: ${greenBlk}\n` +
           `Test commands: ${commands}`,
       },
     ],
     details: {
       enabled: true,
       phase: state.current,
-      allowedRedPhaseFiles: config.allowedRedPhaseFiles,
-      allowedGreenPhaseFiles: config.allowedGreenPhaseFiles,
+      blockedInRed: config.blockedInRed,
+      blockedInGreen: config.blockedInGreen,
       testCommands: config.testCommands,
     },
   };
@@ -366,7 +366,7 @@ export function registerTools(pi: ExtensionAPI): void {
     label: "TDD Status",
     description:
       "Show the current TDD enforcement status: enabled/disabled, current phase, " +
-      "allowed file globs, and test commands.",
+      "blocked file globs per phase, and test commands.",
     parameters: Type.Object({}),
     execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
       return executeTddStatus(ctx, defaultTddStatusDeps);

package/engine/config.test.ts

@@ -28,8 +28,8 @@ describe("loadConfig", () => {
       writeFileSync(
         join(tddDir, "rules.json"),
         JSON.stringify({
-          allowedRedPhaseFiles: ["tests/**/*.test.ts"],
-          allowedGreenPhaseFiles: ["src/**/*.ts"],
+          blockedInRed: ["tests/**/*.test.ts"],
+          blockedInGreen: ["src/**/*.ts"],
           testCommands: ["npm run test"],
           timeoutSeconds: 60,
         }),
@@ -37,7 +37,7 @@ describe("loadConfig", () => {
       );
 
       const config = loadConfig(dir);
-      expect(config.allowedRedPhaseFiles).toEqual(["tests/**/*.test.ts"]);
+      expect(config.blockedInRed).toEqual(["tests/**/*.test.ts"]);
       expect(config.timeoutSeconds).toBe(60);
     });
   });
@@ -49,8 +49,8 @@ describe("loadConfig", () => {
       writeFileSync(
         join(tddDir, "rules.json"),
         JSON.stringify({
-          allowedRedPhaseFiles: ["tests/**/*.test.ts"],
-          allowedGreenPhaseFiles: ["src/**/*.ts"],
+          blockedInRed: ["tests/**/*.test.ts"],
+          blockedInGreen: ["src/**/*.ts"],
           testCommands: ["npm run test:unit", "npm run test:integration"],
         }),
         "utf-8",
@@ -62,15 +62,15 @@ describe("loadConfig", () => {
   });
 
   describe("validation — throws on invalid content", () => {
-    it("throws when allowedRedPhaseFiles is not an array", () => {
+    it("throws when blockedInRed is not an array", () => {
       withTempDir((dir) => {
         const tddDir = join(dir, ".pi", "tdd");
         mkdirSync(tddDir, { recursive: true });
         writeFileSync(
           join(tddDir, "rules.json"),
           JSON.stringify({
-            allowedRedPhaseFiles: "not-an-array",
-            allowedGreenPhaseFiles: ["src/**/*.ts"],
+            blockedInRed: "not-an-array",
+            blockedInGreen: ["src/**/*.ts"],
             testCommands: ["npm test"],
           }),
           "utf-8",
@@ -79,15 +79,15 @@ describe("loadConfig", () => {
       });
     });
 
-    it("throws when allowedGreenPhaseFiles is not an array", () => {
+    it("throws when blockedInGreen is not an array", () => {
       withTempDir((dir) => {
         const tddDir = join(dir, ".pi", "tdd");
         mkdirSync(tddDir, { recursive: true });
         writeFileSync(
           join(tddDir, "rules.json"),
           JSON.stringify({
-            allowedRedPhaseFiles: ["tests/**/*.test.ts"],
-            allowedGreenPhaseFiles: null,
+            blockedInRed: ["tests/**/*.test.ts"],
+            blockedInGreen: null,
             testCommands: ["npm test"],
           }),
           "utf-8",
@@ -103,8 +103,8 @@ describe("loadConfig", () => {
         writeFileSync(
           join(tddDir, "rules.json"),
           JSON.stringify({
-            allowedRedPhaseFiles: ["tests/**/*.test.ts"],
-            allowedGreenPhaseFiles: ["src/**/*.ts"],
+            blockedInRed: ["tests/**/*.test.ts"],
+            blockedInGreen: ["src/**/*.ts"],
             testCommands: "npm test",
           }),
           "utf-8",
@@ -122,15 +122,15 @@ describe("loadConfig", () => {
       });
     });
 
-    it("throws when allowedRedPhaseFiles is empty", () => {
+    it("throws when blockedInRed is empty", () => {
       withTempDir((dir) => {
         const tddDir = join(dir, ".pi", "tdd");
         mkdirSync(tddDir, { recursive: true });
         writeFileSync(
           join(tddDir, "rules.json"),
           JSON.stringify({
-            allowedRedPhaseFiles: [],
-            allowedGreenPhaseFiles: ["src/**/*.ts"],
+            blockedInRed: [],
+            blockedInGreen: ["src/**/*.ts"],
             testCommands: ["npm test"],
           }),
           "utf-8",
@@ -139,15 +139,15 @@ describe("loadConfig", () => {
       });
     });
 
-    it("throws when allowedGreenPhaseFiles is empty", () => {
+    it("throws when blockedInGreen is empty", () => {
       withTempDir((dir) => {
         const tddDir = join(dir, ".pi", "tdd");
         mkdirSync(tddDir, { recursive: true });
         writeFileSync(
           join(tddDir, "rules.json"),
           JSON.stringify({
-            allowedRedPhaseFiles: ["tests/**/*.test.ts"],
-            allowedGreenPhaseFiles: [],
+            blockedInRed: ["tests/**/*.test.ts"],
+            blockedInGreen: [],
             testCommands: ["npm test"],
           }),
           "utf-8",
@@ -163,8 +163,8 @@ describe("loadConfig", () => {
         writeFileSync(
           join(tddDir, "rules.json"),
           JSON.stringify({
-            allowedRedPhaseFiles: ["tests/**/*.test.ts"],
-            allowedGreenPhaseFiles: ["src/**/*.ts"],
+            blockedInRed: ["tests/**/*.test.ts"],
+            blockedInGreen: ["src/**/*.ts"],
             testCommands: [],
           }),
           "utf-8",

package/engine/config.ts

@@ -13,19 +13,19 @@ export function loadConfig(projectRoot: string): Config {
   const raw = readFileSync(path, "utf-8");
   const parsed = JSON.parse(raw);
 
-  if (!Array.isArray(parsed.allowedRedPhaseFiles) || parsed.allowedRedPhaseFiles.length === 0) {
-    throw new Error("rules.json: allowedRedPhaseFiles must be a non-empty array");
+  if (!Array.isArray(parsed.blockedInRed) || parsed.blockedInRed.length === 0) {
+    throw new Error("rules.json: blockedInRed must be a non-empty array");
   }
-  if (!Array.isArray(parsed.allowedGreenPhaseFiles) || parsed.allowedGreenPhaseFiles.length === 0) {
-    throw new Error("rules.json: allowedGreenPhaseFiles must be a non-empty array");
+  if (!Array.isArray(parsed.blockedInGreen) || parsed.blockedInGreen.length === 0) {
+    throw new Error("rules.json: blockedInGreen must be a non-empty array");
   }
   if (!Array.isArray(parsed.testCommands) || parsed.testCommands.length === 0) {
     throw new Error("rules.json: testCommands must be a non-empty array");
   }
 
   return {
-    allowedRedPhaseFiles: parsed.allowedRedPhaseFiles,
-    allowedGreenPhaseFiles: parsed.allowedGreenPhaseFiles,
+    blockedInRed: parsed.blockedInRed,
+    blockedInGreen: parsed.blockedInGreen,
     testCommands: parsed.testCommands,
     timeoutSeconds: parsed.timeoutSeconds ?? 120,
   };

package/engine/enforce.test.ts

@@ -3,8 +3,8 @@ import { isAllowed, disallowedFiles } from "./enforce.js";
 import type { Config } from "./types.js";
 
 const testConfig: Config = {
-  allowedRedPhaseFiles: ["tests/**/*.test.ts", "specs/**/*.spec.ts"],
-  allowedGreenPhaseFiles: ["src/**/*.ts", "lib/**/*.ts"],
+  blockedInRed: ["src/**/*.ts", "lib/**/*.ts"],
+  blockedInGreen: ["tests/**/*.test.ts", "specs/**/*.spec.ts"],
   testCommands: ["npm test"],
   timeoutSeconds: 30,
 };
@@ -16,41 +16,114 @@ describe("isAllowed", () => {
   });
 
   describe("red phase", () => {
-    it("allows red phase files", () => {
-      expect(isAllowed("tests/unit/foo.test.ts", "red", testConfig)).toBe(true);
-      expect(isAllowed("specs/api.spec.ts", "red", testConfig)).toBe(true);
+    it("allows free files", () => {
+      expect(isAllowed("README.md", "red", testConfig)).toBe(true);
+      expect(isAllowed("package.json", "red", testConfig)).toBe(true);
     });
 
-    it("blocks green phase files", () => {
+    it("blocks files in blockedInRed", () => {
       expect(isAllowed("src/main.ts", "red", testConfig)).toBe(false);
       expect(isAllowed("lib/helper.ts", "red", testConfig)).toBe(false);
     });
 
-    it("allows free files (match neither)", () => {
-      expect(isAllowed("README.md", "red", testConfig)).toBe(true);
-      expect(isAllowed("package.json", "red", testConfig)).toBe(true);
+    it("allows test files in red phase", () => {
+      expect(isAllowed("tests/foo.test.ts", "red", testConfig)).toBe(true);
+      expect(isAllowed("specs/api.spec.ts", "red", testConfig)).toBe(true);
     });
   });
 
   describe("green phase", () => {
-    it("allows green phase files", () => {
+    it("allows free files", () => {
+      expect(isAllowed("README.md", "green", testConfig)).toBe(true);
+    });
+
+    it("allows implementation files in green phase", () => {
       expect(isAllowed("src/main.ts", "green", testConfig)).toBe(true);
       expect(isAllowed("lib/helper.ts", "green", testConfig)).toBe(true);
     });
 
-    it("blocks red phase files", () => {
-      expect(isAllowed("tests/unit/foo.test.ts", "green", testConfig)).toBe(false);
+    it("blocks files in blockedInGreen", () => {
+      expect(isAllowed("tests/foo.test.ts", "green", testConfig)).toBe(false);
       expect(isAllowed("specs/api.spec.ts", "green", testConfig)).toBe(false);
     });
+  });
 
-    it("allows free files", () => {
-      expect(isAllowed("README.md", "green", testConfig)).toBe(true);
+  describe("negation patterns (!)", () => {
+    const exclConfig: Config = {
+      blockedInRed: ["src/**/*.ts"],
+      blockedInGreen: ["src/**/*.ts", "!**/*.test.ts"],
+      testCommands: ["npm test"],
+      timeoutSeconds: 30,
+    };
+
+    it("excludes files matching !pattern from the block", () => {
+      expect(isAllowed("src/main.test.ts", "green", exclConfig)).toBe(true);
     });
-  });
 
-  it("handles nested glob patterns", () => {
-    expect(isAllowed("src/deep/nested/file.ts", "green", testConfig)).toBe(true);
-    expect(isAllowed("tests/deep/nested/test.test.ts", "red", testConfig)).toBe(true);
+    it("still blocks files not matching the exclusion", () => {
+      expect(isAllowed("src/main.ts", "green", exclConfig)).toBe(false);
+    });
+
+    it("excludes spec files with a second !pattern", () => {
+      const multiExcl: Config = {
+        blockedInRed: [],
+        blockedInGreen: ["src/**/*.ts", "!**/*.test.ts", "!**/*.spec.ts"],
+        testCommands: [],
+        timeoutSeconds: 30,
+      };
+      expect(isAllowed("src/main.spec.ts", "green", multiExcl)).toBe(true);
+      expect(isAllowed("src/main.test.ts", "green", multiExcl)).toBe(true);
+      expect(isAllowed("src/main.ts", "green", multiExcl)).toBe(false);
+    });
+
+    it("excludes via complex glob in negation pattern", () => {
+      const complexExcl: Config = {
+        blockedInRed: [],
+        blockedInGreen: ["src/**", "!src/vendor/**"],
+        testCommands: [],
+        timeoutSeconds: 30,
+      };
+      expect(isAllowed("src/vendor/lib.js", "green", complexExcl)).toBe(true);
+      expect(isAllowed("src/app.ts", "green", complexExcl)).toBe(false);
+      expect(isAllowed("src/utils/helper.ts", "green", complexExcl)).toBe(false);
+    });
+
+    it("supports ! negation in blockedInRed as well", () => {
+      const redExcl: Config = {
+        blockedInRed: ["src/**/*.ts", "!src/**/*.test.ts"],
+        blockedInGreen: [],
+        testCommands: [],
+        timeoutSeconds: 30,
+      };
+      // test file excluded from block → allowed in red
+      expect(isAllowed("src/main.test.ts", "red", redExcl)).toBe(true);
+      // impl file still blocked
+      expect(isAllowed("src/main.ts", "red", redExcl)).toBe(false);
+      // free file unaffected
+      expect(isAllowed("README.md", "red", redExcl)).toBe(true);
+    });
+
+    it("free file with exclusions in config remains free", () => {
+      expect(isAllowed("README.md", "green", exclConfig)).toBe(true);
+    });
+
+    it("file matching !pattern alone (no positive match) is not blocked", () => {
+      // File matches the negation pattern but NOT the positive pattern.
+      // MatchPatterns returns false (no positive match), so it's not blocked.
+      expect(isAllowed("other/foo.test.ts", "green", exclConfig)).toBe(true);
+    });
+
+    it("exclusion-only patterns block nothing", () => {
+      const exclOnly: Config = {
+        blockedInRed: [],
+        blockedInGreen: ["!**/*.test.ts"],
+        testCommands: [],
+        timeoutSeconds: 30,
+      };
+      expect(isAllowed("any/file.ts", "green", exclOnly)).toBe(true);
+      expect(isAllowed("README.md", "green", exclOnly)).toBe(true);
+      expect(isAllowed("tests/foo.test.ts", "green", exclOnly)).toBe(true);
+    });
   });
 });
 
@@ -64,12 +137,12 @@ describe("disallowedFiles", () => {
     expect(disallowedFiles([], "green", testConfig)).toEqual([]);
   });
 
-  it("filters out green files in red phase", () => {
+  it("filters out blockedInRed files in red phase", () => {
     const files = ["src/main.ts", "README.md", "tests/foo.test.ts"];
     expect(disallowedFiles(files, "red", testConfig)).toEqual(["src/main.ts"]);
   });
 
-  it("filters out red files in green phase", () => {
+  it("filters out blockedInGreen files in green phase", () => {
     const files = ["tests/foo.test.ts", "README.md", "src/main.ts"];
     expect(disallowedFiles(files, "green", testConfig)).toEqual(["tests/foo.test.ts"]);
   });
@@ -79,11 +152,4 @@ describe("disallowedFiles", () => {
     expect(disallowedFiles(free, "red", testConfig)).toEqual([]);
     expect(disallowedFiles(free, "green", testConfig)).toEqual([]);
   });
-
-  it("blocks everything when all files match the other phase", () => {
-    const redFiles = ["tests/a.test.ts", "specs/b.spec.ts"];
-    const greenFiles = ["src/c.ts", "lib/d.ts"];
-    expect(disallowedFiles(redFiles, "green", testConfig)).toEqual(redFiles);
-    expect(disallowedFiles(greenFiles, "red", testConfig)).toEqual(greenFiles);
-  });
 });

package/engine/enforce.ts

@@ -1,25 +1,49 @@
 import picomatch from "picomatch";
 import type { Phase, Config } from "./types.js";
 
+/**
+ * Match a file path against a list of glob patterns with !exclusion support.
+ *
+ * Positive patterns (no ! prefix) include a file in the match.
+ * Negative patterns (! prefix) exclude a file from the match.
+ * A file matches if it matches any positive pattern AND no negative pattern.
+ * Empty pattern list = no match.
+ */
+function matchPatterns(patterns: string[], filePath: string): boolean {
+  const positive: string[] = [];
+  const negative: string[] = [];
+
+  for (const p of patterns) {
+    if (p.startsWith("!")) {
+      negative.push(p.slice(1));
+    } else {
+      positive.push(p);
+    }
+  }
+
+  if (positive.length === 0) return false;
+
+  const matchesPositive = positive.some((p) => picomatch(p)(filePath));
+  if (!matchesPositive) return false;
+
+  const matchesNegative = negative.some((p) => picomatch(p)(filePath));
+  return !matchesNegative;
+}
+
 /**
  * Check if a file path is allowed to be modified in the current phase.
  *
  * Rules:
  * - REFACTOR: everything allowed
- * - RED: files matching allowedRedPhaseFiles + free files (match neither set)
- * - GREEN: files matching allowedGreenPhaseFiles + free files
- * - Free files (matching neither glob set) are always allowed in all phases
+ * - RED: files in blockedInRed are blocked, everything else is free
+ * - GREEN: files in blockedInGreen are blocked, everything else is free
+ * - ! negation patterns exclude subsets from a block list
  */
 export function isAllowed(filePath: string, phase: Phase, config: Config): boolean {
   if (phase === "refactor") return true;
 
-  const matchesRed = config.allowedRedPhaseFiles.some((p) => picomatch(p)(filePath));
-  const matchesGreen = config.allowedGreenPhaseFiles.some((p) => picomatch(p)(filePath));
-
-  if (phase === "red") return matchesRed || (!matchesRed && !matchesGreen);
-  if (phase === "green") return matchesGreen || (!matchesRed && !matchesGreen);
-
-  return true;
+  const blocked = phase === "red" ? config.blockedInRed : config.blockedInGreen;
+  return !matchPatterns(blocked, filePath);
 }
 
 /**

package/engine/transition.test.ts

@@ -33,8 +33,8 @@ function makeRunner(passed: boolean): TestRunner {
 }
 
 const testConfig: Config = {
-  allowedRedPhaseFiles: [],
-  allowedGreenPhaseFiles: [],
+  blockedInRed: [],
+  blockedInGreen: [],
   testCommands: ["npm test"],
   timeoutSeconds: 30,
 };
@@ -124,8 +124,8 @@ describe("checkGate", () => {
 // ── Pure unit tests: getDisallowedChanges ────────────────────────────────────
 
 const denyConfig: Config = {
-  allowedRedPhaseFiles: ["tests/**/*.test.ts"],
-  allowedGreenPhaseFiles: ["src/**/*.ts"],
+  blockedInRed: ["src/**/*.ts"],
+  blockedInGreen: ["tests/**/*.test.ts"],
   testCommands: [],
   timeoutSeconds: 30,
 };
@@ -163,11 +163,10 @@ describe("getDisallowedChanges", () => {
 
   it("returns disallowed files in red phase", () => {
     mockChangesSinceSnapshot.mockReturnValue(["src/main.ts", "tests/foo.test.ts", "README.md"]);
-    const matchesRed = picomatch(denyConfig.allowedRedPhaseFiles);
-    const matchesGreen = picomatch(denyConfig.allowedGreenPhaseFiles);
+    const matchBlockedInRed = picomatch(denyConfig.blockedInRed);
     mockDisallowedFiles.mockImplementation((changed: string[], phase: string) => {
       if (phase === "red") {
-        return changed.filter((f: string) => !matchesRed(f) && matchesGreen(f));
+        return changed.filter((f: string) => matchBlockedInRed(f));
       }
       return [];
     });
@@ -179,11 +178,10 @@ describe("getDisallowedChanges", () => {
 
   it("returns disallowed files in green phase", () => {
     mockChangesSinceSnapshot.mockReturnValue(["tests/foo.test.ts", "src/main.ts", "package.json"]);
-    const matchesRed = picomatch(denyConfig.allowedRedPhaseFiles);
-    const matchesGreen = picomatch(denyConfig.allowedGreenPhaseFiles);
+    const matchBlockedInGreen = picomatch(denyConfig.blockedInGreen);
     mockDisallowedFiles.mockImplementation((changed: string[], phase: string) => {
       if (phase === "green") {
-        return changed.filter((f: string) => matchesRed(f) && !matchesGreen(f));
+        return changed.filter((f: string) => matchBlockedInGreen(f));
       }
       return [];
     });
@@ -195,11 +193,10 @@ describe("getDisallowedChanges", () => {
 
   it("catches untracked files, not just modified", () => {
     mockChangesSinceSnapshot.mockReturnValue(["src/new.ts"]);
-    const matchesRed = picomatch(denyConfig.allowedRedPhaseFiles);
-    const matchesGreen = picomatch(denyConfig.allowedGreenPhaseFiles);
+    const matchBlockedInRed = picomatch(denyConfig.blockedInRed);
     mockDisallowedFiles.mockImplementation((changed: string[], phase: string) => {
       if (phase === "red") {
-        return changed.filter((f: string) => !matchesRed(f) && matchesGreen(f));
+        return changed.filter((f: string) => matchBlockedInRed(f));
       }
       return [];
     });

package/engine/types.ts

@@ -6,8 +6,8 @@ export interface PhaseState {
 }
 
 export interface Config {
-  allowedRedPhaseFiles: string[];
-  allowedGreenPhaseFiles: string[];
+  blockedInRed: string[];
+  blockedInGreen: string[];
   testCommands: string[];
   timeoutSeconds: number;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tdd-enforcer",
-  "version": "0.2.3",
+  "version": "0.2.6",
   "type": "module",
   "keywords": [
     "pi-package"

package/skills/tdd-enforcer/SKILL.md

@@ -28,19 +28,20 @@ It locks files per phase — only test files in RED, only implementation files i
 
 ## Setup
 
-1. **Agent** creates `.pi/tdd/rules.json` with these fields:
+1. **Agent** checks if the repo has a test framework set up. If it doesn't, stop and ask the user what they want. Do not make assumptions, pick defaults, or proceed without their explicit decision. Then create `.pi/tdd/rules.json` with these fields:
 
 ```json
 {
-  "allowedRedPhaseFiles": ["tests/**/*.test.ts"],
-  "allowedGreenPhaseFiles": ["src/**/*.ts"],
-  "testCommands": ["npm test"],
+  "blockedInRed":   ["src/**/*.ts", "lib/**/*.ts", "!src/**/*.test.ts"],
+  "blockedInGreen": ["**/*.test.ts"],
+  "testCommands":   ["npm test"],
   "timeoutSeconds": 30
 }
 ```
 
-- `allowedRedPhaseFiles` — globs the agent can create/modify in RED phase (tests)
-- `allowedGreenPhaseFiles` — globs the agent can create/modify in GREEN phase (implementation)
+- `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
 - `timeoutSeconds` — test timeout per command
 
@@ -51,31 +52,31 @@ It locks files per phase — only test files in RED, only implementation files i
 ## Phase Rules
 
 ### RED
-Write failing tests matching `allowedRedPhaseFiles` patterns. Files matching `allowedGreenPhaseFiles` are locked. Files matching neither set are always free. Call `next_tdd_phase` once tests fail.
+Files matching `blockedInRed` are locked — everything else is free.
 
-### GREEN
-Implement features matching `allowedGreenPhaseFiles` patterns. Test files from `allowedRedPhaseFiles` are locked. Files matching neither set are always free. Call `next_tdd_phase` once tests pass.
+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.
 
-### REFACTOR
-All files are free to modify. Refactor without changing behaviour. Call `next_tdd_phase` once tests pass to start a new RED cycle.
+Call `next_tdd_phase` once tests fail.
 
----
+### GREEN
+Files matching `blockedInGreen` are locked — everything else is free.
 
-## Hard Rules
+Write the simplest code that makes the failing tests pass — nothing more. The tests are your spec; if they pass, you're done.
 
-- **Never bypass TDD.** If TDD blocks a change, it's because you're in the wrong phase or the file isn't allowed in this phase. The solution is always to work within the rules, not around them.
+If the RED phase tests were wrong, call `previous_tdd_phase` to go back and fix them before implementing. All current changes are lost, but that's better since the current changes was building on false assumptions. Don't be afraid to discard — clean slate beats patched code.
 
-  - Need to change a locked file? Either advance through the cycle (`next_tdd_phase`) or roll back to fix earlier work (`previous_tdd_phase`).
-  - Wrong assumptions about the task? Roll back with `previous_tdd_phase`, the phase restarts clean.
-  - Fundamentally blocked? Ask the user to run the appropriate `/tdd:` command (change phase, disable, or reset).
+Call `next_tdd_phase` once all tests pass.
 
-- **Never write to `.pi/tdd/`.** The extension owns that directory — writes are blocked and bash changes are reverted. Any change you make there is ignored or overwritten.
+### REFACTOR
+All files are free to modify. Refactor without changing behaviour.
+Call `next_tdd_phase` once tests pass to start a new RED cycle.
 
-- **Never run `/tdd:` commands yourself.** They're registered as user-only commands. They won't work when you type them.
+---
 
-- **Don't be afraid to discard.** If the previous phase work was wrong, all current-phase changes are built on false assumptions. Prefer a clean slate — call `previous_tdd_phase` and redo it properly.
+## Hard Rules
 
-- **Keep cycles small but tests comprehensive.** Write tests for one feature at a time. Cover happy path, edge cases, and unhappy paths before moving to GREEN. Small cycles mean less to lose if assumptions turn out wrong. Reverting becomes cheap and safe.
+- **Never write to `.pi/tdd/`.** The extension owns that directory — writes are blocked and bash changes are reverted.
+- **Never run `/tdd:` commands yourself.** They're registered as user-only commands and won't work when you type them.
 
 ---
 
@@ -93,7 +94,7 @@ Also validates no locked files were modified. On success, records the current st
 Use when the previous phase's work was wrong and the current phase cannot proceed because of it. Rolls back to the previous phase so that work can be redone correctly. All changes made in the current phase are lost.
 
 ### `tdd_status`
-Shows the current phase, allowed file globs, and test commands.
+Shows the current phase, blocked file globs per phase, and test commands.
 
 ---