oh-my-harness 0.4.2 → 0.6.0

package/README.md

@@ -368,6 +368,24 @@ No code changes required. The registry auto-discovers it.
 
 ---
 
+## Contributing
+
+Contributions are welcome! Please read the [Contributing Guide](CONTRIBUTING.md) before submitting a PR.
+
+---
+
+## Support This Project
+
+oh-my-harness is free and open source. Here's how you can help:
+
+- **Star** — [Give a star](https://github.com/kyu1204/oh-my-harness) to help others discover the project
+- **Report Bugs** — [Open an issue](https://github.com/kyu1204/oh-my-harness/issues/new) when something doesn't work
+- **Request Features** — [Suggest ideas](https://github.com/kyu1204/oh-my-harness/issues/new) for new presets, hooks, or emitters
+- **Contribute** — Fix a bug, add a preset, or improve docs — PRs are always welcome
+- **Spread the Word** — Share oh-my-harness with your team or community
+
+---
+
 ## License
 
 MIT

package/dist/cli/command-checker.d.ts

@@ -0,0 +1,15 @@
+export interface CommandCheckResult {
+    command: string;
+    category: string;
+    executable: boolean;
+    error?: string;
+}
+export declare function extractExecutable(command: string): string;
+export declare function checkCommandExecutable(binary: string): Promise<boolean>;
+export declare function extractPreCommitCommands(hookContent: string): string[];
+export declare function extractPostSaveCommands(hookContent: string): string[];
+export declare function checkHarnessCommands(hooks: {
+    event: string;
+    matcher: string;
+    command: string;
+}[], projectDir: string): Promise<CommandCheckResult[]>;

package/dist/cli/command-checker.js

@@ -0,0 +1,104 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+// 명령어에서 바이너리 추출 (첫 토큰, 래퍼 처리)
+export function extractExecutable(command) {
+    const parts = command.trim().split(/\s+/);
+    // npm run X → npm
+    // npx X → npx
+    // bash script.sh → bash
+    return parts[0];
+}
+// 명령어 실행 가능 여부 확인
+export async function checkCommandExecutable(binary) {
+    try {
+        await execFileAsync("which", [binary]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// pre-commit hook 스크립트에서 실행되는 명령어 추출
+export function extractPreCommitCommands(hookContent) {
+    const commands = [];
+    // 패턴: if ! <command> 또는 직접 명령 실행
+    const matches = hookContent.matchAll(/if\s+!\s+(.+?)\s+>&?2/g);
+    for (const match of matches) {
+        commands.push(match[1].trim());
+    }
+    return commands;
+}
+// post-save hook 스크립트에서 실행되는 명령어 추출
+export function extractPostSaveCommands(hookContent) {
+    const commands = [];
+    // 패턴: <command> "$FILE_PATH" 또는 <command> --fix "$FILE_PATH"
+    const lines = hookContent.split("\n");
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // eslint --fix "$FILE_PATH" 패턴
+        if (trimmed.includes("$FILE_PATH") &&
+            !trimmed.startsWith("#") &&
+            !trimmed.startsWith("if") &&
+            !trimmed.startsWith("FILE_PATH") &&
+            !trimmed.startsWith("BASENAME") &&
+            !trimmed.startsWith("echo ")) {
+            const cmd = trimmed.split(/\s+"\$FILE_PATH"/)[0].trim();
+            if (cmd && !cmd.startsWith("[")) {
+                commands.push(cmd);
+            }
+        }
+    }
+    return commands;
+}
+// 전체 명령어 체크
+export async function checkHarnessCommands(hooks, projectDir) {
+    const results = [];
+    const fs = await import("node:fs/promises");
+    const path = await import("node:path");
+    for (const hook of hooks) {
+        const scriptPath = hook.command.replace(/^bash\s+/, "");
+        const fullPath = path.join(projectDir, scriptPath);
+        let content;
+        try {
+            content = await fs.readFile(fullPath, "utf-8");
+        }
+        catch {
+            continue; // 스크립트 파일 없으면 스킵
+        }
+        const scriptName = path.basename(scriptPath);
+        // pre-commit gate류 — 파일명 매칭 확장 + 내용 기반 감지
+        if (scriptName.includes("pre-commit") ||
+            scriptName.includes("test-gate") ||
+            scriptName.includes("typecheck-gate") ||
+            scriptName.includes("before-commit") ||
+            /if\s+!\s+.+\s+>&?2/.test(content)) {
+            const commands = extractPreCommitCommands(content);
+            const isTypecheck = scriptName.includes("typecheck") || commands.some((c) => /\btsc\b/.test(c));
+            const category = isTypecheck ? "commit-typecheck-gate" : "commit-test-gate";
+            for (const cmd of commands) {
+                const binary = extractExecutable(cmd);
+                const executable = await checkCommandExecutable(binary);
+                results.push({ command: cmd, category, executable });
+            }
+        }
+        // post-save류 (lint-on-save, format-on-save)
+        if (scriptName.includes("post-save") ||
+            scriptName.includes("lint-on-save") ||
+            scriptName.includes("format-on-save")) {
+            const commands = extractPostSaveCommands(content);
+            const category = scriptName.includes("format") ? "format-on-save" : "lint-on-save";
+            for (const cmd of commands) {
+                const binary = extractExecutable(cmd);
+                const executable = await checkCommandExecutable(binary);
+                results.push({ command: cmd, category, executable });
+            }
+        }
+        // auto-pr (gh CLI 체크)
+        if (scriptName.includes("auto-pr")) {
+            const hasGh = await checkCommandExecutable("gh");
+            results.push({ command: "gh", category: "auto-pr", executable: hasGh });
+        }
+    }
+    return results;
+}

package/dist/cli/commands/init.js

@@ -131,7 +131,10 @@ async function initWithNL(projectDir, presetsDir, options) {
     const stackNames = harness.project.stacks.map((s) => `${s.name} (${s.framework})`).join(", ");
     console.log(`\nStacks: ${stackNames}`);
     console.log(`Rules: ${harness.rules.length}`);
-    console.log(`Pre-commit checks: ${harness.enforcement.preCommit.join(", ") || "none"}`);
+    const { mergeEnforcementAndHooks } = await import("../../core/harness-converter.js");
+    const allHooks = mergeEnforcementAndHooks(harness);
+    const hookSummary = allHooks.map((h) => h.block).join(", ") || "none";
+    console.log(`Hooks: ${hookSummary}`);
     if (!options.yes) {
         const { confirm } = await import("@inquirer/prompts");
         const ok = await confirm({ message: "Proceed with this configuration?", default: true });

package/dist/cli/commands/test.d.ts

@@ -0,0 +1,12 @@
+import type { TestResult } from "../harness-tester.js";
+import type { CommandCheckResult } from "../command-checker.js";
+export interface TestCommandOptions {
+    projectDir?: string;
+}
+export declare function formatCategoryName(category: string): string;
+export declare function testCommand(options?: TestCommandOptions): Promise<{
+    passed: number;
+    failed: number;
+    results: TestResult[];
+    commandResults: CommandCheckResult[];
+}>;

package/dist/cli/commands/test.js

@@ -0,0 +1,139 @@
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import fs from "node:fs/promises";
+import path from "node:path";
+import yaml from "js-yaml";
+import { getRegisteredHooks, generateBlockTestCases, runTestCase } from "../harness-tester.js";
+import { checkHarnessCommands } from "../command-checker.js";
+import { HarnessConfigSchema } from "../../core/harness-schema.js";
+import { mergeEnforcementAndHooks } from "../../core/harness-converter.js";
+import { builtinBlocks } from "../../catalog/blocks/index.js";
+export function formatCategoryName(category) {
+    const names = {
+        "path-guard": "File guards",
+        "command-guard": "Command guards",
+        "branch-guard": "Branch guard",
+        "lockfile-guard": "Lockfile guard",
+        "secret-file-guard": "Secret file guard",
+        "commit-test-gate": "Pre-commit test gate",
+        "commit-typecheck-gate": "Pre-commit typecheck gate",
+        "lint-on-save": "Lint on save",
+        "format-on-save": "Format on save",
+        "auto-pr": "Auto PR",
+        "tdd-guard": "TDD Guard",
+    };
+    return names[category] ?? category;
+}
+export async function testCommand(options = {}) {
+    const projectDir = options.projectDir ?? process.cwd();
+    // 1. harness.yaml 읽기
+    const harnessPath = path.join(projectDir, "harness.yaml");
+    let hookEntries = [];
+    try {
+        const raw = await fs.readFile(harnessPath, "utf-8");
+        const parsed = yaml.load(raw);
+        const result = HarnessConfigSchema.safeParse(parsed);
+        if (result.success) {
+            // Merge enforcement-derived hooks with explicit hooks
+            hookEntries = mergeEnforcementAndHooks(result.data);
+        }
+        else {
+            console.log(chalk.yellow(`Warning: harness.yaml schema validation failed: ${result.error.message}`));
+        }
+    }
+    catch (err) {
+        const error = err;
+        if (error.code !== "ENOENT") {
+            console.log(chalk.red(`Error reading harness.yaml: ${error.message}`));
+            process.exit(1);
+        }
+        // ENOENT: harness.yaml 없으면 settings.json만으로 진행
+    }
+    // 2. settings.json에서 등록된 hook 가져오기
+    let hooks;
+    try {
+        hooks = await getRegisteredHooks(projectDir);
+    }
+    catch (err) {
+        const error = err;
+        if (error.code === "ENOENT") {
+            console.log(chalk.red("harness not initialized. Run `omh init` first."));
+        }
+        else {
+            console.log(chalk.red(`Failed to read settings.json: ${error.message}`));
+        }
+        process.exit(1);
+    }
+    if (hooks.length === 0) {
+        console.log(chalk.yellow("No hooks registered in settings.json."));
+        return { passed: 0, failed: 0, results: [], commandResults: [] };
+    }
+    // 3. 시뮬레이션 테스트 케이스 생성 + 실행
+    p.intro(`${chalk.bgCyan(chalk.black(" omh test "))} ${chalk.dim("Harness dry-run verification")}`);
+    // 현재 브랜치 가져오기
+    let currentBranch;
+    try {
+        const { execFile: execFileCb } = await import("node:child_process");
+        const { promisify: promisifyFn } = await import("node:util");
+        const execFileAsync = promisifyFn(execFileCb);
+        const { stdout } = await execFileAsync("git", ["branch", "--show-current"], { cwd: projectDir });
+        currentBranch = stdout.trim() || undefined;
+    }
+    catch {
+        // git 없으면 undefined
+    }
+    // Generate test cases from block-based hooks only
+    const testCases = generateBlockTestCases(hookEntries, builtinBlocks, currentBranch);
+    const results = [];
+    // 카테고리별 그룹핑
+    const categories = [...new Set(testCases.map((tc) => tc.category))];
+    for (const category of categories) {
+        const casesInCategory = testCases.filter((tc) => tc.category === category);
+        const categoryResults = [];
+        for (const tc of casesInCategory) {
+            const result = await runTestCase(projectDir, tc);
+            categoryResults.push(result);
+            results.push(result);
+        }
+        // 카테고리 출력
+        const lines = categoryResults.map((r) => {
+            if (r.passed) {
+                return `  ${chalk.green("✓")} ${r.testCase.name}`;
+            }
+            else {
+                const hint = r.error ?? `expected ${r.testCase.expectation} but got ${r.actual}`;
+                return `  ${chalk.red("✗")} ${r.testCase.name}\n    ${chalk.dim(hint)}`;
+            }
+        });
+        p.note(lines.join("\n"), formatCategoryName(category));
+    }
+    // 4. 명령어 실행 가능 체크
+    const commandResults = await checkHarnessCommands(hooks, projectDir);
+    if (commandResults.length > 0) {
+        const cmdLines = commandResults.map((r) => {
+            if (r.executable) {
+                return `  ${chalk.green("✓")} ${r.command} — executable`;
+            }
+            else {
+                return `  ${chalk.red("✗")} ${r.command} — ${chalk.red("not found")}`;
+            }
+        });
+        p.note(cmdLines.join("\n"), "Command checks");
+    }
+    // 5. 결과 요약
+    const hookPassed = results.filter((r) => r.passed).length;
+    const hookFailed = results.filter((r) => !r.passed).length;
+    const cmdPassed = commandResults.filter((r) => r.executable).length;
+    const cmdFailed = commandResults.filter((r) => !r.executable).length;
+    const totalPassed = hookPassed + cmdPassed;
+    const totalFailed = hookFailed + cmdFailed;
+    const total = totalPassed + totalFailed;
+    if (totalFailed === 0) {
+        p.outro(chalk.green(`${totalPassed}/${total} checks passed ✓`));
+    }
+    else {
+        p.outro(chalk.red(`${totalFailed}/${total} checks failed`));
+        process.exit(1);
+    }
+    return { passed: totalPassed, failed: totalFailed, results, commandResults };
+}

package/dist/cli/event-verifier.d.ts

@@ -0,0 +1,8 @@
+import { type HookEvent } from "./event-logger.js";
+export interface EventVerification {
+    verified: boolean;
+    matchedEvent?: HookEvent;
+    warning?: string;
+}
+export declare function getEventSnapshot(projectDir: string): Promise<number>;
+export declare function verifyEventLogged(projectDir: string, snapshotCount: number, expectedHook: string, expectedDecision: "block" | "allow"): Promise<EventVerification>;

package/dist/cli/event-verifier.js

@@ -0,0 +1,29 @@
+import { readEvents } from "./event-logger.js";
+// 테스트 실행 전 스냅샷 카운트 가져오기
+export async function getEventSnapshot(projectDir) {
+    const events = await readEvents(projectDir);
+    return events.length;
+}
+// 테스트 실행 후 새 이벤트에서 hook 매칭 확인
+export async function verifyEventLogged(projectDir, snapshotCount, expectedHook, expectedDecision) {
+    const events = await readEvents(projectDir);
+    const newEvents = events.slice(snapshotCount);
+    if (newEvents.length === 0) {
+        return { verified: false, warning: "No new events recorded in events.jsonl" };
+    }
+    // hook 이름 매칭 (정규화 후 동등 비교: catalog-command-guard.sh → command-guard)
+    const normalize = (name) => name.replace(/\.sh$/, "").replace(/^catalog-/, "").replace(/^harness-/, "");
+    const normalizedExpected = normalize(expectedHook);
+    const matched = newEvents.find((e) => normalize(e.hook) === normalizedExpected);
+    if (!matched) {
+        return { verified: false, warning: `No event found for hook "${expectedHook}"` };
+    }
+    if (matched.decision !== expectedDecision) {
+        return {
+            verified: false,
+            matchedEvent: matched,
+            warning: `Event logged decision="${matched.decision}" but expected "${expectedDecision}"`,
+        };
+    }
+    return { verified: true, matchedEvent: matched };
+}

package/dist/cli/harness-tester.d.ts

@@ -0,0 +1,37 @@
+import type { HookEntry, BuildingBlock } from "../catalog/types.js";
+export interface HookInput {
+    tool_name: string;
+    tool_input: Record<string, unknown>;
+}
+export interface HookResult {
+    decision: "block" | "allow";
+    reason?: string;
+}
+export interface TestCase {
+    name: string;
+    category: string;
+    hookScript: string;
+    input: HookInput;
+    expectation: "block" | "allow";
+    setup?: (projectDir: string) => Promise<void>;
+    teardown?: (projectDir: string) => Promise<void>;
+}
+export interface TestResult {
+    testCase: TestCase;
+    actual: "block" | "allow";
+    passed: boolean;
+    reason?: string;
+    error?: string;
+}
+export declare function simulateHook(hookPath: string, input: HookInput, cwd?: string): Promise<HookResult>;
+export declare function getRegisteredHooks(projectDir: string): Promise<{
+    event: string;
+    matcher: string;
+    command: string;
+}[]>;
+export declare function runTestCase(projectDir: string, testCase: TestCase): Promise<TestResult>;
+export declare function generateBlockTestCases(hookEntries: HookEntry[], blocks: BuildingBlock[], currentBranch?: string, registeredHooks?: {
+    event: string;
+    matcher: string;
+    command: string;
+}[]): TestCase[];

package/dist/cli/harness-tester.js

@@ -0,0 +1,289 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { applyDefaults } from "../catalog/template-engine.js";
+// 핵심 함수: hook 스크립트에 JSON stdin을 넣고 결과 파싱
+export async function simulateHook(hookPath, input, cwd) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            child.kill();
+            resolve({ decision: "allow" });
+        }, 5000);
+        const child = spawn("bash", [hookPath], {
+            cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let stdout = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.on("close", () => {
+            clearTimeout(timer);
+            const trimmed = stdout.trim();
+            if (!trimmed) {
+                resolve({ decision: "allow" });
+                return;
+            }
+            // stdout에서 {"decision":"block","reason":"..."} 찾기
+            const jsonMatch = trimmed.match(/\{[^}]*"decision"\s*:\s*"block"[^}]*\}/);
+            if (jsonMatch) {
+                try {
+                    const parsed = JSON.parse(jsonMatch[0]);
+                    resolve({ decision: "block", reason: parsed.reason });
+                }
+                catch {
+                    resolve({ decision: "allow" });
+                }
+                return;
+            }
+            resolve({ decision: "allow" });
+        });
+        child.on("error", () => {
+            clearTimeout(timer);
+            resolve({ decision: "allow" });
+        });
+        // EPIPE 방지: 자식 프로세스가 이미 종료된 경우 stdin 에러 무시
+        child.stdin.on("error", () => { });
+        child.stdin.write(JSON.stringify(input));
+        child.stdin.end();
+    });
+}
+// settings.json에서 등록된 hook 스크립트 목록 가져오기
+export async function getRegisteredHooks(projectDir) {
+    const settingsPath = path.join(projectDir, ".claude", "settings.json");
+    const raw = await fs.readFile(settingsPath, "utf-8");
+    const settings = JSON.parse(raw);
+    const hooks = [];
+    for (const event of ["PreToolUse", "PostToolUse"]) {
+        const eventHooks = settings.hooks?.[event];
+        if (!Array.isArray(eventHooks))
+            continue;
+        for (const entry of eventHooks) {
+            const matcher = entry.matcher ?? "";
+            for (const hook of entry.hooks ?? []) {
+                if (hook.type === "command" && hook.command) {
+                    hooks.push({ event, matcher, command: hook.command });
+                }
+            }
+        }
+    }
+    return hooks;
+}
+// 테스트 실행
+export async function runTestCase(projectDir, testCase) {
+    const hookPath = path.join(projectDir, testCase.hookScript);
+    try {
+        await fs.access(hookPath);
+    }
+    catch {
+        if (testCase.teardown)
+            await testCase.teardown(projectDir);
+        return {
+            testCase,
+            actual: "allow",
+            passed: false,
+            error: `Hook script not found: ${testCase.hookScript}`,
+        };
+    }
+    if (testCase.setup)
+        await testCase.setup(projectDir);
+    try {
+        const result = await simulateHook(hookPath, testCase.input, projectDir);
+        const passed = result.decision === testCase.expectation;
+        return {
+            testCase,
+            actual: result.decision,
+            passed,
+            reason: result.reason,
+            error: passed ? undefined : `expected ${testCase.expectation} but got ${result.decision}`,
+        };
+    }
+    finally {
+        if (testCase.teardown)
+            await testCase.teardown(projectDir);
+    }
+}
+// 블록 기반 테스트 케이스 생성
+export function generateBlockTestCases(hookEntries, blocks, currentBranch, registeredHooks) {
+    const cases = [];
+    for (const entry of hookEntries) {
+        const block = blocks.find((b) => b.id === entry.block);
+        if (!block)
+            continue;
+        if (!block.canBlock)
+            continue;
+        const params = applyDefaults(block, entry.params);
+        // Find actual script path from registered hooks, fallback to catalog- prefix
+        // Map block ids to enforcement script name patterns
+        const blockIdAliases = {
+            "path-guard": ["path-guard", "file-guard"],
+            "command-guard": ["command-guard"],
+            "branch-guard": ["branch-guard"],
+            "lockfile-guard": ["lockfile-guard"],
+            "secret-file-guard": ["secret-file-guard"],
+            "tdd-guard": ["tdd-guard"],
+        };
+        const aliases = blockIdAliases[block.id] ?? [block.id];
+        const matchedHook = registeredHooks?.find((h) => {
+            const scriptName = h.command.replace(/^bash\s+/, "");
+            return aliases.some((alias) => scriptName.includes(alias));
+        });
+        const hookScript = matchedHook
+            ? matchedHook.command.replace(/^bash\s+/, "")
+            : `.claude/hooks/catalog-${block.id}.sh`;
+        switch (block.id) {
+            case "path-guard": {
+                const blockedPaths = params.blockedPaths ?? [];
+                for (const blocked of blockedPaths) {
+                    const testPath = blocked.endsWith("/")
+                        ? `${blocked}test-file.js`
+                        : blocked.startsWith("*")
+                            ? `test${blocked.slice(1)}`
+                            : blocked;
+                    cases.push({
+                        name: `${testPath} → BLOCKED`,
+                        category: "path-guard",
+                        hookScript,
+                        input: { tool_name: "Edit", tool_input: { file_path: testPath } },
+                        expectation: "block",
+                    });
+                }
+                cases.push({
+                    name: "src/index.ts → ALLOWED",
+                    category: "path-guard",
+                    hookScript,
+                    input: { tool_name: "Edit", tool_input: { file_path: "src/index.ts" } },
+                    expectation: "allow",
+                });
+                break;
+            }
+            case "command-guard": {
+                const patterns = params.patterns ?? [];
+                for (const pattern of patterns) {
+                    cases.push({
+                        name: `"${pattern}" → BLOCKED`,
+                        category: "command-guard",
+                        hookScript,
+                        input: { tool_name: "Bash", tool_input: { command: pattern } },
+                        expectation: "block",
+                    });
+                }
+                cases.push({
+                    name: '"npm test" → ALLOWED',
+                    category: "command-guard",
+                    hookScript,
+                    input: { tool_name: "Bash", tool_input: { command: "npm test" } },
+                    expectation: "allow",
+                });
+                break;
+            }
+            case "branch-guard": {
+                const isProtected = currentBranch === "main" || currentBranch === "master";
+                cases.push({
+                    name: `git commit on ${currentBranch ?? "unknown"} → ${isProtected ? "BLOCKED" : "ALLOWED"}`,
+                    category: "branch-guard",
+                    hookScript,
+                    input: { tool_name: "Bash", tool_input: { command: "git commit -m 'test'" } },
+                    expectation: isProtected ? "block" : "allow",
+                });
+                break;
+            }
+            case "lockfile-guard": {
+                cases.push({
+                    name: "package-lock.json → BLOCKED",
+                    category: "lockfile-guard",
+                    hookScript,
+                    input: { tool_name: "Edit", tool_input: { file_path: "package-lock.json" } },
+                    expectation: "block",
+                });
+                cases.push({
+                    name: "package.json → ALLOWED",
+                    category: "lockfile-guard",
+                    hookScript,
+                    input: { tool_name: "Edit", tool_input: { file_path: "package.json" } },
+                    expectation: "allow",
+                });
+                break;
+            }
+            case "secret-file-guard": {
+                cases.push({
+                    name: ".env → BLOCKED",
+                    category: "secret-file-guard",
+                    hookScript,
+                    input: { tool_name: "Edit", tool_input: { file_path: ".env" } },
+                    expectation: "block",
+                });
+                cases.push({
+                    name: "src/app.ts → ALLOWED",
+                    category: "secret-file-guard",
+                    hookScript,
+                    input: { tool_name: "Edit", tool_input: { file_path: "src/app.ts" } },
+                    expectation: "allow",
+                });
+                break;
+            }
+            case "tdd-guard": {
+                const stateFile = ".claude/hooks/.state/edit-history.json";
+                // block case: source file without prior test edit
+                cases.push({
+                    name: "src/event-logger.ts without test → BLOCKED",
+                    category: "tdd-guard",
+                    hookScript,
+                    input: { tool_name: "Edit", tool_input: { file_path: "src/event-logger.ts" } },
+                    expectation: "block",
+                    setup: async (projectDir) => {
+                        const historyPath = path.join(projectDir, stateFile);
+                        try {
+                            await fs.unlink(historyPath);
+                        }
+                        catch {
+                            // file may not exist
+                        }
+                    },
+                    teardown: async (projectDir) => {
+                        const historyPath = path.join(projectDir, stateFile);
+                        try {
+                            await fs.unlink(historyPath);
+                        }
+                        catch {
+                            // file may not exist
+                        }
+                    },
+                });
+                // allow case: test file edit
+                cases.push({
+                    name: "tests/unit/event-logger.test.ts → ALLOWED",
+                    category: "tdd-guard",
+                    hookScript,
+                    input: { tool_name: "Edit", tool_input: { file_path: "tests/unit/event-logger.test.ts" } },
+                    expectation: "allow",
+                    setup: async (projectDir) => {
+                        const historyPath = path.join(projectDir, stateFile);
+                        const stateDir = path.dirname(historyPath);
+                        await fs.mkdir(stateDir, { recursive: true });
+                        await fs.writeFile(historyPath, JSON.stringify({ edits: [] }));
+                    },
+                    teardown: async (projectDir) => {
+                        const historyPath = path.join(projectDir, stateFile);
+                        try {
+                            await fs.unlink(historyPath);
+                        }
+                        catch {
+                            // file may not exist
+                        }
+                    },
+                });
+                // allow case: non-code file
+                cases.push({
+                    name: "README.md → ALLOWED",
+                    category: "tdd-guard",
+                    hookScript,
+                    input: { tool_name: "Edit", tool_input: { file_path: "README.md" } },
+                    expectation: "allow",
+                });
+                break;
+            }
+        }
+    }
+    return cases;
+}