draht-claude 2026.4.23

package/commands/verify-work.md

@@ -0,0 +1,72 @@
+---
+description: Acceptance testing of completed phase work (parallel verifier, security-auditor, and reviewer subagents)
+argument-hint: "<phase-number>"
+allowed-tools: Bash, Read, Write, Edit, Task
+---
+
+# /verify-work
+
+Walk through acceptance testing of completed phase work, using subagents for parallel verification.
+
+Phase: $1
+
+> **Tool note**: Invoke `draht-tools <subcommand>` as `node "${CLAUDE_PLUGIN_ROOT}/bin/draht-tools.cjs" <subcommand>`. For subagents, use the **Task tool** and dispatch multiple in parallel (single assistant turn = multiple Task tool calls).
+
+## Atomic Reasoning
+
+Before verifying, decompose phase acceptance into atomic reasoning units:
+
+**For each deliverable:**
+1. **State the logical component** — What was this deliverable meant to produce? What user value does it provide?
+2. **Validate independence** — Can this deliverable be tested independently? What are its dependencies?
+3. **Verify correctness** — What tests prove it works? What edge cases must pass? What security concerns exist?
+
+**Synthesize verification strategy:**
+- Group parallel verification tasks (test suite, security audit, code review, domain compliance)
+- Map each deliverable to specific test scenarios and acceptance criteria
+- Identify critical vs optional checks
+- Plan fix strategies for potential failures
+
+## Steps
+1. Run `draht-tools extract-deliverables $1` to get testable items
+
+2. **Run parallel verification via the Task tool**:
+   Dispatch these three subagents in parallel (single assistant turn, three Task tool calls):
+
+   - **Task tool** with `subagent_type: "verifier"` and prompt:
+     "Run the full test suite for this project. Check package.json for the test command. Record pass/fail counts. Then run any available lint and typecheck commands (e.g. npm run check, npm run lint, npx tsc --noEmit). Report all results with error details."
+
+   - **Task tool** with `subagent_type: "security-auditor"` and prompt:
+     "Audit the recent code changes (use git log and git diff to find them). Check for injection risks, auth bypasses, secrets in code, unsafe patterns. Report findings by severity."
+
+   - **Task tool** with `subagent_type: "reviewer"` and prompt:
+     "Review the recent code changes (use git log and git diff). Check domain language compliance against `.planning/DOMAIN.md` if it exists — scan for identifiers not in the glossary and cross-context boundary violations. Report findings."
+
+3. Run the quality gate check:
+   ```bash
+   node "${CLAUDE_PLUGIN_ROOT}/scripts/gsd-quality-gate.cjs"
+   ```
+4. Collect results from all subagents and the quality gate
+5. Walk the user through each deliverable one at a time, incorporating findings from the parallel checks
+6. Record results (pass/fail/partially/skip)
+7. For failures: diagnose and create fix plans via `draht-tools create-fix-plan $1 P`
+   - Fix plans MUST include a reproducing test that demonstrates the failure before any implementation
+8. Write UAT report: `draht-tools write-uat $1`
+   - Report must include: test health summary (pass/fail/coverage), security audit results, domain model status (any glossary violations), deliverable results
+9. If all passed: mark phase complete.
+   - If more phases remain in the milestone: tell the user to start a fresh session and run `/discuss-phase N+1`.
+   - If ALL phases in the milestone are complete: tell the user to start a fresh session and run `/next-milestone`.
+10. If failures: route to `/execute-phase $1 --gaps-only`
+
+## Workflow
+This is the last step in the per-phase cycle:
+
+```
+/discuss-phase N → /plan-phase N → /execute-phase N → /verify-work N
+```
+
+After verify-work passes:
+- More phases remaining → `/discuss-phase N+1`
+- ALL phases in milestone verified → `/next-milestone`
+
+`/next-milestone` is ONLY for generating new phases after every phase in the current milestone is complete.

package/hooks/hooks.json

@@ -0,0 +1,26 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/session-start.cjs\""
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/prompt-context.cjs\""
+          }
+        ]
+      }
+    ]
+  }
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+	"name": "draht-claude",
+	"version": "2026.4.23",
+	"description": "Draht GSD, multi-agent, TDD and DDD workflows as a Claude Code plugin. Install with `npx draht-claude install`.",
+	"type": "module",
+	"bin": {
+		"draht-claude": "./cli.mjs"
+	},
+	"files": [
+		".claude-plugin",
+		"bin",
+		"scripts",
+		"hooks",
+		"commands",
+		"agents",
+		"skills",
+		"cli.mjs",
+		"README.md",
+		"LICENSE",
+		"CHANGELOG.md"
+	],
+	"scripts": {
+		"test": "node cli.mjs --help > /dev/null && node scripts/gsd-pre-execute.cjs --self-check 2>/dev/null || true"
+	},
+	"keywords": [
+		"claude-code",
+		"claude-code-plugin",
+		"draht",
+		"gsd",
+		"planning",
+		"tdd",
+		"ddd",
+		"multi-agent",
+		"workflow",
+		"installer"
+	],
+	"author": "Mario Zechner",
+	"license": "MIT",
+	"publishConfig": {
+		"access": "public"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/draht-dev/draht.git",
+		"directory": "packages/draht-claude"
+	},
+	"engines": {
+		"node": ">=20.6.0"
+	}
+}

package/scripts/gsd-post-phase.cjs

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * Draht Post-Phase Hook
+ * Runs after phase completion to generate reports and update state.
+ *
+ * Usage: node gsd-post-phase.js <phase-number>
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const phaseNum = process.argv[2];
+if (!phaseNum) {
+	console.error("Usage: gsd-post-phase.js <phase-number>");
+	process.exit(1);
+}
+
+const PLANNING = ".planning";
+const LOG_FILE = path.join(PLANNING, "execution-log.jsonl");
+
+// 1. Read execution log for this phase
+let entries = [];
+if (fs.existsSync(LOG_FILE)) {
+	entries = fs.readFileSync(LOG_FILE, "utf-8")
+		.split("\n")
+		.filter(Boolean)
+		.map((l) => JSON.parse(l))
+		.filter((e) => e.phase === parseInt(phaseNum, 10));
+}
+
+const passed = entries.filter((e) => e.status === "pass").length;
+const failed = entries.filter((e) => e.status === "fail").length;
+const skipped = entries.filter((e) => e.status === "skip").length;
+const warnings = entries.filter((e) => e.warning).length;
+
+// 2. Compute TDD and domain health metrics
+const tddViolations = entries.filter((e) => e.status === "tdd-violation").length;
+
+// TDD commit counts: derive from git log scoped to commits since phase start
+// (use the earliest entry timestamp as the lower bound)
+let tddSummary = "⚠️  No TDD commit data in log";
+try {
+	const { execSync } = require("node:child_process");
+	// Scope to commits that follow TDD naming convention for this phase
+	const gitLog = execSync(
+		`git log --format=%s --grep="^[0-9]" -E --extended-regexp 2>/dev/null || git log --format=%s 2>/dev/null`,
+		{ encoding: "utf-8" }
+	).trim();
+	const lines = gitLog.split("\n");
+	const redCount = lines.filter((l) => /^red:/i.test(l)).length;
+	const greenCount = lines.filter((l) => /^green:/i.test(l)).length;
+	const refactorCount = lines.filter((l) => /^refactor:/i.test(l)).length;
+	if (redCount + greenCount + refactorCount > 0) {
+		tddSummary = `🔴 Red: ${redCount}  🟢 Green: ${greenCount}  🔵 Refactor: ${refactorCount}`;
+	} else {
+		tddSummary = "⚠️  No red:/green:/refactor: commits found — TDD cycle may not have been followed";
+	}
+} catch { /* ignore */ }
+
+// Domain health: check DOMAIN.md presence and glossary size
+let domainSummary = "⚠️  .planning/DOMAIN.md not found";
+const domainPath = path.join(PLANNING, "DOMAIN.md");
+if (fs.existsSync(domainPath)) {
+	const domainContent = fs.readFileSync(domainPath, "utf-8");
+	const termMatches = [...domainContent.matchAll(/\b([A-Z][a-zA-Z0-9]+)\b/g)];
+	const termCount = new Set(termMatches.map((m) => m[1])).size;
+	const hasContexts = domainContent.includes("## Bounded Contexts");
+	const hasGlossary = domainContent.includes("## Ubiquitous Language");
+	domainSummary = `${hasContexts ? "✅" : "❌"} Bounded Contexts  ${hasGlossary ? "✅" : "❌"} Ubiquitous Language  📖 ~${termCount} terms`;
+}
+
+// TEST-STRATEGY health
+let testStrategySummary = "⚠️  .planning/TEST-STRATEGY.md not found";
+if (fs.existsSync(path.join(PLANNING, "TEST-STRATEGY.md"))) {
+	testStrategySummary = "✅ TEST-STRATEGY.md present";
+}
+
+// 3. Generate phase report
+const reportPath = path.join(PLANNING, `phase-${phaseNum}-report.md`);
+const report = `# Phase ${phaseNum} Execution Report
+
+Generated: ${new Date().toISOString().replace("T", " ").slice(0, 19)}
+
+## Task Results
+- ✅ Passed: ${passed}
+- ❌ Failed: ${failed}
+- ⏭️  Skipped: ${skipped}
+- ⚠️  Warnings: ${warnings}
+
+## Execution Log
+| Timestamp | Plan | Task | Status | Commit |
+|-----------|------|------|--------|--------|
+${entries.map((e) => `| ${e.timestamp.slice(0, 19)} | ${e.plan} | ${e.task} | ${e.status} | ${e.commit || "-"} |`).join("\n")}
+
+## Quality Gate
+${failed === 0 ? "✅ All tasks passed — ready for verification" : `❌ ${failed} failure(s) — fix plans may be needed`}
+${warnings > 0 ? `⚠️  ${warnings} task(s) introduced type errors` : "✅ No type errors introduced"}
+
+## TDD Health
+${tddSummary}
+${tddViolations > 0 ? `❌ ${tddViolations} TDD cycle violation(s) recorded (green: without red:)` : "✅ No TDD cycle violations recorded"}
+
+## Domain Model Health
+${domainSummary}
+${testStrategySummary}
+`;
+
+fs.writeFileSync(reportPath, report);
+console.log(`Phase ${phaseNum} report: ${reportPath}`);
+
+// 4. Update ROADMAP.md status
+const roadmapPath = path.join(PLANNING, "ROADMAP.md");
+if (fs.existsSync(roadmapPath)) {
+	let roadmap = fs.readFileSync(roadmapPath, "utf-8");
+	const newStatus = failed === 0 ? "complete" : "needs-fixes";
+	const regex = new RegExp(`(## Phase ${phaseNum}:.+?)— \`\\w+\``, "m");
+	roadmap = roadmap.replace(regex, `$1— \`${newStatus}\``);
+	fs.writeFileSync(roadmapPath, roadmap);
+	console.log(`ROADMAP.md: Phase ${phaseNum} → ${newStatus}`);
+}
+
+// 5. Summary
+console.log(`\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+console.log(` Draht ► PHASE ${phaseNum} ${failed === 0 ? "COMPLETE ✅" : "NEEDS FIXES ❌"}`);
+console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+console.log(`\n${passed} passed, ${failed} failed, ${skipped} skipped`);
+if (failed === 0) {
+	console.log(`\nNext: gsd-verify-work ${phaseNum}`);
+} else {
+	console.log(`\nNext: gsd-execute-phase ${phaseNum} --gaps-only`);
+}

package/scripts/gsd-post-task.cjs

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * Draht Post-Task Hook
+ * Runs after each task execution to validate and record results.
+ *
+ * Usage: node gsd-post-task.js <phase> <plan> <task-num> <status> [commit-hash]
+ * Status: pass | fail | skip
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { execSync } = require("node:child_process");
+
+const [phaseNum, planNum, taskNum, status, commitHash] = process.argv.slice(2);
+if (!phaseNum || !planNum || !taskNum || !status) {
+	console.error("Usage: gsd-post-task.js <phase> <plan> <task-num> <status> [commit-hash]");
+	process.exit(1);
+}
+
+// ── Toolchain detection — mirrors src/gsd/hook-utils.ts ──────────────────────
+function detectToolchain(cwd) {
+	if (fs.existsSync(path.join(cwd, "bun.lockb")) || fs.existsSync(path.join(cwd, "bun.lock"))) {
+		return { pm: "bun", testCmd: "bun test", coverageCmd: "bun test --coverage", lintCmd: "bunx biome check ." };
+	}
+	if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) {
+		return { pm: "pnpm", testCmd: "pnpm test", coverageCmd: "pnpm run test:coverage", lintCmd: "pnpm run lint" };
+	}
+	if (fs.existsSync(path.join(cwd, "yarn.lock"))) {
+		return { pm: "yarn", testCmd: "yarn test", coverageCmd: "yarn run test:coverage", lintCmd: "yarn run lint" };
+	}
+	return { pm: "npm", testCmd: "npm test", coverageCmd: "npm run test:coverage", lintCmd: "npm run lint" };
+}
+
+function readHookConfig(cwd) {
+	const defaults = { coverageThreshold: 80, tddMode: "advisory", qualityGateStrict: false };
+	const configPath = path.join(cwd, ".planning", "config.json");
+	if (!fs.existsSync(configPath)) return defaults;
+	try {
+		const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+		const h = raw.hooks || {};
+		return {
+			coverageThreshold: typeof h.coverageThreshold === "number" ? h.coverageThreshold : defaults.coverageThreshold,
+			tddMode: h.tddMode === "strict" || h.tddMode === "advisory" ? h.tddMode : defaults.tddMode,
+			qualityGateStrict: typeof h.qualityGateStrict === "boolean" ? h.qualityGateStrict : defaults.qualityGateStrict,
+		};
+	} catch { return defaults; }
+}
+
+const PLANNING = ".planning";
+const LOG_FILE = path.join(PLANNING, "execution-log.jsonl");
+const cwd = process.cwd();
+const toolchain = detectToolchain(cwd);
+const hookConfig = readHookConfig(cwd);
+
+// 0. TDD cycle compliance check
+if (commitHash) {
+	try {
+		const currentMsg = execSync(`git log --format=%s -n 1 ${commitHash} 2>/dev/null`, { encoding: "utf-8" }).trim();
+		if (/^green:/i.test(currentMsg)) {
+			const taskPrefix = `${phaseNum}-${planNum}-${taskNum}`;
+			const recentMsgs = execSync(`git log --format=%s -n 50 ${commitHash}~1 2>/dev/null`, { encoding: "utf-8" })
+				.trim()
+				.split("\n")
+				.filter((m) => m.includes(taskPrefix) || /^(red|green|refactor):/i.test(m));
+			const prevTaskMsg = recentMsgs.find((m) => /^(red|green|refactor):/i.test(m) && m.includes(taskPrefix));
+			if (!prevTaskMsg || !/^red:/i.test(prevTaskMsg)) {
+				const violation = `TDD violation: "green:" commit without preceding "red:" for task ${phaseNum}-${planNum}-${taskNum}`;
+				if (hookConfig.tddMode === "strict") {
+					console.error(`❌ ${violation}`);
+					process.exit(1);
+				} else {
+					console.log(`⚠️  ${violation}`);
+				}
+				fs.appendFileSync(LOG_FILE, JSON.stringify({
+					timestamp: new Date().toISOString(),
+					phase: parseInt(phaseNum, 10),
+					plan: parseInt(planNum, 10),
+					task: parseInt(taskNum, 10),
+					status: "tdd-violation",
+					warning: "green: commit without preceding red: commit",
+					commit: commitHash,
+				}) + "\n");
+			}
+		}
+	} catch {
+		// Not a git repo or commit not found — ignore
+	}
+}
+
+// 1. Append to execution log
+const entry = {
+	timestamp: new Date().toISOString(),
+	phase: parseInt(phaseNum, 10),
+	plan: parseInt(planNum, 10),
+	task: parseInt(taskNum, 10),
+	status,
+	commit: commitHash || null,
+};
+
+fs.appendFileSync(LOG_FILE, JSON.stringify(entry) + "\n");
+
+// 2. Run type check and tests if status is pass
+if (status === "pass") {
+	// Type check
+	try {
+		const tsCmd = toolchain.pm === "bun" ? "bun run tsgo --noEmit 2>&1" : "npx tsc --noEmit 2>&1";
+		execSync(tsCmd, { timeout: 30000, encoding: "utf-8", cwd });
+		// Run tests
+		try {
+			const testOutput = execSync(`${toolchain.testCmd} 2>&1`, { timeout: 60000, encoding: "utf-8", cwd });
+			const testMatch = testOutput.match(/(\d+) pass/);
+			const testCount = testMatch ? testMatch[1] : "?";
+			console.log(`✅ Task ${phaseNum}-${planNum}-${taskNum}: passed + types clean + ${testCount} tests pass`);
+		} catch (testErr) {
+			const testOut = testErr.stdout || testErr.stderr || "";
+			const failMatch = testOut.match(/(\d+) fail/);
+			if (failMatch) {
+				console.log(`⚠️  Task ${phaseNum}-${planNum}-${taskNum}: passed + types clean but ${failMatch[1]} test(s) failed`);
+			} else {
+				console.log(`✅ Task ${phaseNum}-${planNum}-${taskNum}: passed + types clean (no test runner found)`);
+			}
+		}
+	} catch (error) {
+		const output = error.stdout || "";
+		const errorCount = (output.match(/error TS/g) || []).length;
+		if (errorCount > 0) {
+			console.log(`⚠️  Task ${phaseNum}-${planNum}-${taskNum}: passed but ${errorCount} type error(s) introduced`);
+			fs.appendFileSync(LOG_FILE, JSON.stringify({
+				...entry,
+				warning: `${errorCount} type errors introduced`,
+			}) + "\n");
+		} else {
+			console.log(`✅ Task ${phaseNum}-${planNum}-${taskNum}: passed`);
+		}
+	}
+} else if (status === "fail") {
+	console.log(`❌ Task ${phaseNum}-${planNum}-${taskNum}: FAILED`);
+
+	// Check if we should create a fix plan
+	const logContent = fs.readFileSync(LOG_FILE, "utf-8");
+	const taskFailures = logContent.split("\n")
+		.filter(Boolean)
+		.map((l) => JSON.parse(l))
+		.filter((e) => e.phase === parseInt(phaseNum, 10) && e.plan === parseInt(planNum, 10) && e.task === parseInt(taskNum, 10) && e.status === "fail");
+
+	if (taskFailures.length >= 3) {
+		console.log(`\n⚠️  Task has failed 3+ times. Consider creating a fix plan:`);
+		console.log(`   draht create-fix-plan ${phaseNum} ${planNum} "Task ${taskNum} failed repeatedly"`);
+	}
+} else {
+	console.log(`⏭️  Task ${phaseNum}-${planNum}-${taskNum}: skipped`);
+}
+
+// 3. Update STATE.md last activity
+const statePath = path.join(PLANNING, "STATE.md");
+if (fs.existsSync(statePath)) {
+	let state = fs.readFileSync(statePath, "utf-8");
+	state = state.replace(
+		/## Last Activity:.*/,
+		`## Last Activity: ${new Date().toISOString().replace("T", " ").slice(0, 19)}`
+	);
+	fs.writeFileSync(statePath, state);
+}

package/scripts/gsd-pre-execute.cjs

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * Draht Pre-Execute Hook
+ * Runs before gsd-execute-phase to validate preconditions.
+ *
+ * Usage: node gsd-pre-execute.js <phase-number>
+ * Exit 0 = proceed, Exit 1 = abort
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { execSync } = require("node:child_process");
+
+const phaseNum = process.argv[2];
+if (!phaseNum) {
+	console.error("Usage: gsd-pre-execute.js <phase-number>");
+	process.exit(1);
+}
+
+const PLANNING = ".planning";
+const errors = [];
+const warnings = [];
+
+// 1. Check .planning/ exists
+if (!fs.existsSync(PLANNING)) {
+	errors.push("No .planning/ directory found. Run gsd-new-project first.");
+}
+
+// 2. Check STATE.md exists
+if (!fs.existsSync(path.join(PLANNING, "STATE.md"))) {
+	errors.push("No STATE.md found. Project not initialized.");
+}
+
+// 3. Check ROADMAP.md exists and phase is defined
+const roadmapPath = path.join(PLANNING, "ROADMAP.md");
+if (fs.existsSync(roadmapPath)) {
+	const roadmap = fs.readFileSync(roadmapPath, "utf-8");
+	if (!roadmap.includes(`Phase ${phaseNum}`)) {
+		errors.push(`Phase ${phaseNum} not found in ROADMAP.md`);
+	}
+} else {
+	errors.push("No ROADMAP.md found.");
+}
+
+// 4. Check phase directory exists with plans
+const phasesDir = path.join(PLANNING, "phases");
+if (fs.existsSync(phasesDir)) {
+	const entries = fs.readdirSync(phasesDir);
+	const phaseDir = entries.find((e) => e.startsWith(String(phaseNum).padStart(2, "0") + "-"));
+	if (!phaseDir) {
+		errors.push(`No phase directory found for phase ${phaseNum}. Run gsd-plan-phase first.`);
+	} else {
+		const phaseFiles = fs.readdirSync(path.join(phasesDir, phaseDir));
+		const plans = phaseFiles.filter((f) => f.endsWith("-PLAN.md") && !f.includes("FIX"));
+		if (plans.length === 0) {
+			errors.push(`No plans found in phase ${phaseNum}. Run gsd-plan-phase first.`);
+		}
+
+		// Check plans have required elements
+		for (const planFile of plans) {
+			const content = fs.readFileSync(path.join(phasesDir, phaseDir, planFile), "utf-8");
+			if (!content.includes("<task")) {
+				warnings.push(`${planFile}: No <task> elements — plan may be incomplete`);
+			}
+			if (!content.includes("<verify>")) {
+				warnings.push(`${planFile}: Missing <verify> steps — tasks won't be verifiable`);
+			}
+		}
+	}
+}
+
+// 5. Check git status
+try {
+	const status = execSync("git status --porcelain", { encoding: "utf-8" }).trim();
+	if (status) {
+		const lines = status.split("\n").length;
+		warnings.push(`${lines} uncommitted file(s) — consider committing first`);
+	}
+} catch {
+	warnings.push("Not a git repository — no commit tracking");
+}
+
+// 6. Check for CONTINUE-HERE.md (unfinished session)
+if (fs.existsSync(path.join(PLANNING, "CONTINUE-HERE.md"))) {
+	warnings.push("CONTINUE-HERE.md exists — previous session may be unfinished. Consider gsd-resume-work.");
+}
+
+// 7. Check DOMAIN.md exists and has required sections
+const domainPath = path.join(PLANNING, "DOMAIN.md");
+if (!fs.existsSync(domainPath)) {
+	warnings.push("No .planning/DOMAIN.md found — domain model not documented. Run /new-project or /map-codebase to create it.");
+} else {
+	const domainContent = fs.readFileSync(domainPath, "utf-8");
+	if (!domainContent.includes("## Bounded Contexts")) {
+		errors.push("DOMAIN.md is missing '## Bounded Contexts' section.");
+	}
+	if (!domainContent.includes("## Ubiquitous Language")) {
+		errors.push("DOMAIN.md is missing '## Ubiquitous Language' section.");
+	}
+}
+
+// 8. Check TEST-STRATEGY.md exists
+if (!fs.existsSync(path.join(PLANNING, "TEST-STRATEGY.md"))) {
+	warnings.push("No .planning/TEST-STRATEGY.md found — test strategy not documented. Run /new-project or /map-codebase to create it.");
+}
+
+// 9. Check all plans have non-empty <test> sections
+if (fs.existsSync(phasesDir)) {
+	const entries2 = fs.readdirSync(phasesDir);
+	const phaseDir2 = entries2.find((e) => e.startsWith(String(phaseNum).padStart(2, "0") + "-"));
+	if (phaseDir2) {
+		const phaseFiles2 = fs.readdirSync(path.join(phasesDir, phaseDir2));
+		const plans2 = phaseFiles2.filter((f) => f.endsWith("-PLAN.md") && !f.includes("FIX"));
+		for (const planFile of plans2) {
+			const content = fs.readFileSync(path.join(phasesDir, phaseDir2, planFile), "utf-8");
+			// Extract all <test>...</test> blocks and check they are non-empty
+			const testMatches = [...content.matchAll(/<test>([\s\S]*?)<\/test>/g)];
+			if (testMatches.length === 0) {
+				errors.push(`${planFile}: Missing <test> sections — TDD requires tests for every task`);
+			} else {
+				for (const m of testMatches) {
+					if (!m[1].trim()) {
+						errors.push(`${planFile}: Empty <test> section found — fill in test cases before executing`);
+					}
+				}
+			}
+		}
+	}
+}
+
+// Output
+if (warnings.length > 0) {
+	console.log(`⚠️  ${warnings.length} warning(s):`);
+	for (const w of warnings) console.log(`  - ${w}`);
+}
+
+if (errors.length > 0) {
+	console.log(`\n❌ ${errors.length} error(s) — cannot proceed:`);
+	for (const e of errors) console.log(`  - ${e}`);
+	process.exit(1);
+}
+
+console.log(`✅ Pre-execute checks passed for phase ${phaseNum}`);
+process.exit(0);