@draht/coding-agent 2026.3.2-2

package/dist/hooks/gsd/draht-post-phase.js

@@ -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/dist/hooks/gsd/draht-post-task.js

@@ -0,0 +1,132 @@
+#!/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);
+}
+
+const PLANNING = ".planning";
+const LOG_FILE = path.join(PLANNING, "execution-log.jsonl");
+
+// 0. TDD cycle compliance check
+// If the current commit message starts with "green:", the previous commit for this
+// task should start with "red:" — enforce the Red → Green order.
+if (commitHash) {
+	try {
+		// Find the commit message for commitHash and the one before it
+		const currentMsg = execSync(`git log --format=%s -n 1 ${commitHash} 2>/dev/null`, { encoding: "utf-8" }).trim();
+		if (/^green:/i.test(currentMsg)) {
+			// Scope search to commits that mention this phase/plan/task in their message
+			// to avoid false positives from unrelated older commits
+			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));
+			// Find the nearest TDD-cycle commit scoped to this task
+			const prevTaskMsg = recentMsgs.find((m) => /^(red|green|refactor):/i.test(m) && m.includes(taskPrefix));
+			if (!prevTaskMsg || !/^red:/i.test(prevTaskMsg)) {
+				console.log(`⚠️  TDD violation: "green:" commit detected but no preceding "red:" commit found for task ${phaseNum}-${planNum}-${taskNum}`);
+				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 if status is pass
+if (status === "pass") {
+	try {
+		execSync("bun run tsgo --noEmit 2>&1", { timeout: 30000, encoding: "utf-8" });
+		// Run tests
+		try {
+			const testOutput = execSync("bun test 2>&1", { timeout: 60000, encoding: "utf-8" });
+			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`);
+			// Append warning to log
+			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/dist/hooks/gsd/draht-pre-execute.js

@@ -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);

package/dist/hooks/gsd/draht-quality-gate.js

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * Draht Quality Gate Hook
+ * Runs after task completion to enforce quality standards.
+ * Called by the build agent after each verify step.
+ *
+ * Usage: node gsd-quality-gate.js [--strict]
+ * Exit 0 = quality OK, Exit 1 = quality issues
+ */
+
+const { execSync } = require("node:child_process");
+const fs = require("node:fs");
+
+const strict = process.argv.includes("--strict");
+const issues = [];
+
+// 1. TypeScript check
+try {
+	execSync("bun run tsgo --noEmit 2>&1", { timeout: 60000, encoding: "utf-8" });
+} catch (error) {
+	const output = error.stdout || error.stderr || "";
+	const errorCount = (output.match(/error TS/g) || []).length;
+	if (errorCount > 0) {
+		issues.push({ severity: strict ? "error" : "warning", message: `${errorCount} TypeScript error(s)`, details: output.slice(0, 500) });
+	}
+}
+
+// 2. Biome lint check (if biome.json exists)
+if (fs.existsSync("biome.json")) {
+	try {
+		execSync("bunx biome check --error-on-warnings . 2>&1", { timeout: 30000, encoding: "utf-8" });
+	} catch (error) {
+		const output = error.stdout || error.stderr || "";
+		issues.push({ severity: strict ? "error" : "warning", message: "Biome lint issues", details: output.slice(0, 500) });
+	}
+}
+
+// 3. Run tests
+try {
+	const testOutput = execSync("bun test 2>&1", { timeout: 120000, encoding: "utf-8" });
+	const failMatch = testOutput.match(/(\d+) fail/);
+	if (failMatch && parseInt(failMatch[1], 10) > 0) {
+		issues.push({ severity: strict ? "error" : "warning", message: `${failMatch[1]} test(s) failing` });
+	}
+} catch (error) {
+	const output = error.stdout || error.stderr || "";
+	const failMatch = output.match(/(\d+) fail/);
+	if (failMatch && parseInt(failMatch[1], 10) > 0) {
+		issues.push({ severity: strict ? "error" : "warning", message: `${failMatch[1]} test(s) failing` });
+	}
+}
+
+// 4. Check for console.log in source files (not tests)
+try {
+	const result = execSync(
+		"grep -rn 'console\\.log' src/ --include='*.ts' --include='*.tsx' 2>/dev/null | grep -v '// debug' | head -5",
+		{ encoding: "utf-8" }
+	).trim();
+	if (result) {
+		issues.push({ severity: "warning", message: `console.log found in source`, details: result });
+	}
+} catch { /* grep returns 1 when no match — that's good */ }
+
+// 5. Domain glossary compliance
+// Extract terms from DOMAIN.md and flag new PascalCase classes not in the glossary
+const domainMdPath = ".planning/DOMAIN.md";
+if (fs.existsSync(domainMdPath)) {
+	try {
+		const domainContent = fs.readFileSync(domainMdPath, "utf-8");
+		// Collect all PascalCase tokens that appear in the glossary section
+		const glossarySection = domainContent.match(/## Ubiquitous Language([\s\S]*?)(?:^##|\Z)/m)?.[1] || "";
+		// Each glossary entry is assumed to start the line with a PascalCase term (e.g. "**Order**" or "- Order:")
+		const glossaryTerms = new Set(
+			[...glossarySection.matchAll(/\b([A-Z][a-zA-Z0-9]+)\b/g)].map((m) => m[1])
+		);
+
+		// Scan changed source files for PascalCase class/interface/type declarations
+		try {
+			const changedFiles = execSync(
+				"git diff --cached --name-only 2>/dev/null || git diff --name-only HEAD~1",
+				{ encoding: "utf-8" }
+			).trim().split("\n").filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+
+			const unknownTerms = [];
+			for (const file of changedFiles) {
+				if (!fs.existsSync(file)) continue;
+				const src = fs.readFileSync(file, "utf-8");
+				const declarations = [...src.matchAll(/(?:class|interface|type|enum)\s+([A-Z][a-zA-Z0-9]+)/g)].map((m) => m[1]);
+				for (const term of declarations) {
+					if (!glossaryTerms.has(term)) {
+						unknownTerms.push(`${file}: ${term}`);
+					}
+				}
+			}
+			if (unknownTerms.length > 0) {
+				issues.push({
+					severity: "warning",
+					message: `${unknownTerms.length} PascalCase type(s) not in DOMAIN.md glossary`,
+					details: unknownTerms.slice(0, 5).join(", "),
+				});
+			}
+		} catch { /* ignore git errors */ }
+	} catch { /* ignore read errors */ }
+}
+
+// 6. Bounded context boundary check — flag suspicious cross-directory imports
+try {
+	const changedSrcFiles = execSync(
+		"git diff --cached --name-only 2>/dev/null || git diff --name-only HEAD~1",
+		{ encoding: "utf-8" }
+	).trim().split("\n").filter((f) => /^src\/[^/]+\//.test(f) && (f.endsWith(".ts") || f.endsWith(".tsx")));
+
+	const crossContextImports = [];
+	for (const file of changedSrcFiles) {
+		if (!fs.existsSync(file)) continue;
+		// Determine this file's context (first path segment under src/)
+		const ownContext = file.split("/")[1];
+		const src = fs.readFileSync(file, "utf-8");
+		const imports = [...src.matchAll(/from\s+['"](\.\.\/.+?)['"]/g)].map((m) => m[1]);
+		for (const imp of imports) {
+			// Resolve relative import against the file's directory
+			const resolved = path.normalize(path.join(path.dirname(file), imp));
+			const parts = resolved.split(path.sep);
+			const srcIdx = parts.indexOf("src");
+			if (srcIdx !== -1 && parts[srcIdx + 1] && parts[srcIdx + 1] !== ownContext) {
+				crossContextImports.push(`${file} → ${parts.slice(srcIdx).join("/")}`);
+			}
+		}
+	}
+	if (crossContextImports.length > 0) {
+		issues.push({
+			severity: "warning",
+			message: `${crossContextImports.length} suspicious cross-context import(s) detected`,
+			details: crossContextImports.slice(0, 3).join("; "),
+		});
+	}
+} catch { /* ignore */ }
+
+// 7. TDD health — check test-to-source file ratio
+try {
+	const allSrc = execSync(
+		"find src -name '*.ts' -not -name '*.test.ts' -not -name '*.spec.ts' 2>/dev/null | wc -l",
+		{ encoding: "utf-8" }
+	).trim();
+	const allTests = execSync(
+		"find src -name '*.test.ts' -o -name '*.spec.ts' 2>/dev/null | wc -l",
+		{ encoding: "utf-8" }
+	).trim();
+	const srcCount = parseInt(allSrc, 10) || 0;
+	const testCount = parseInt(allTests, 10) || 0;
+	if (srcCount > 0) {
+		const ratio = testCount / srcCount;
+		if (ratio < 0.3) {
+			issues.push({
+				severity: "warning",
+				message: `TDD health: test-to-source ratio is ${(ratio * 100).toFixed(0)}% (${testCount} tests / ${srcCount} sources) — target ≥ 30%`,
+			});
+		}
+	}
+} catch { /* ignore — src/ may not exist */ }
+
+// 8. Check for TODO/FIXME/HACK comments in changed files
+try {
+	const diff = execSync("git diff --cached --name-only 2>/dev/null || git diff --name-only HEAD~1", { encoding: "utf-8" }).trim();
+	if (diff) {
+		const files = diff.split("\n").filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+		for (const file of files) {
+			try {
+				const content = fs.readFileSync(file, "utf-8");
+				const todos = content.match(/\/\/\s*(TODO|FIXME|HACK|XXX):/gi) || [];
+				if (todos.length > 0) {
+					issues.push({ severity: "info", message: `${file}: ${todos.length} TODO/FIXME comment(s)` });
+				}
+			} catch { /* file may not exist */ }
+		}
+	}
+} catch { /* ignore */ }
+
+// Output
+const errors = issues.filter((i) => i.severity === "error");
+const warnings = issues.filter((i) => i.severity === "warning");
+const infos = issues.filter((i) => i.severity === "info");
+
+if (errors.length > 0) {
+	console.log(`\n❌ Quality Gate FAILED (${errors.length} error(s)):`);
+	for (const e of errors) {
+		console.log(`  ❌ ${e.message}`);
+		if (e.details) console.log(`     ${e.details.split("\n")[0]}`);
+	}
+}
+
+if (warnings.length > 0) {
+	console.log(`\n⚠️  ${warnings.length} warning(s):`);
+	for (const w of warnings) {
+		console.log(`  ⚠️  ${w.message}`);
+	}
+}
+
+if (infos.length > 0) {
+	console.log(`\nℹ️  ${infos.length} note(s):`);
+	for (const i of infos) console.log(`  ℹ️  ${i.message}`);
+}
+
+if (errors.length === 0 && warnings.length === 0) {
+	console.log("✅ Quality gate passed");
+}
+
+process.exit(errors.length > 0 ? 1 : 0);

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+export { getAgentDir, VERSION } from "./config.js";
+export { AgentSession, type AgentSessionConfig, type AgentSessionEvent, type AgentSessionEventListener, type ModelCycleResult, type ParsedSkillBlock, type PromptOptions, parseSkillBlock, type SessionStats, } from "./core/agent-session.js";
+export { type ApiKeyCredential, type AuthCredential, AuthStorage, type AuthStorageBackend, FileAuthStorageBackend, InMemoryAuthStorageBackend, type OAuthCredential, } from "./core/auth-storage.js";
+export { type BranchPreparation, type BranchSummaryResult, type CollectEntriesResult, type CompactionResult, type CutPointResult, calculateContextTokens, collectEntriesForBranchSummary, compact, DEFAULT_COMPACTION_SETTINGS, estimateTokens, type FileOperations, findCutPoint, findTurnStartIndex, type GenerateBranchSummaryOptions, generateBranchSummary, generateSummary, getLastAssistantUsage, prepareBranchEntries, serializeConversation, shouldCompact, } from "./core/compaction/index.js";
+export { createEventBus, type EventBus, type EventBusController } from "./core/event-bus.js";
+export type { AgentEndEvent, AgentStartEvent, AgentToolResult, AgentToolUpdateCallback, AppAction, BashToolCallEvent, BeforeAgentStartEvent, CompactOptions, ContextEvent, ContextUsage, CustomToolCallEvent, EditToolCallEvent, ExecOptions, ExecResult, Extension, ExtensionActions, ExtensionAPI, ExtensionCommandContext, ExtensionCommandContextActions, ExtensionContext, ExtensionContextActions, ExtensionError, ExtensionEvent, ExtensionFactory, ExtensionFlag, ExtensionHandler, ExtensionRuntime, ExtensionShortcut, ExtensionUIContext, ExtensionUIDialogOptions, ExtensionWidgetOptions, FindToolCallEvent, GrepToolCallEvent, InputEvent, InputEventResult, InputSource, KeybindingsManager, LoadExtensionsResult, LsToolCallEvent, MessageRenderer, MessageRenderOptions, ProviderConfig, ProviderModelConfig, ReadToolCallEvent, RegisteredCommand, RegisteredTool, SessionBeforeCompactEvent, SessionBeforeForkEvent, SessionBeforeSwitchEvent, SessionBeforeTreeEvent, SessionCompactEvent, SessionForkEvent, SessionShutdownEvent, SessionStartEvent, SessionSwitchEvent, SessionTreeEvent, SlashCommandInfo, SlashCommandLocation, SlashCommandSource, TerminalInputHandler, ToolCallEvent, ToolDefinition, ToolInfo, ToolRenderResultOptions, ToolResultEvent, TurnEndEvent, TurnStartEvent, UserBashEvent, UserBashEventResult, WidgetPlacement, WriteToolCallEvent, } from "./core/extensions/index.js";
+export { createExtensionRuntime, discoverAndLoadExtensions, ExtensionRunner, isBashToolResult, isEditToolResult, isFindToolResult, isGrepToolResult, isLsToolResult, isReadToolResult, isToolCallEventType, isWriteToolResult, wrapRegisteredTool, wrapRegisteredTools, wrapToolsWithExtensions, wrapToolWithExtensions, } from "./core/extensions/index.js";
+export type { ReadonlyFooterDataProvider } from "./core/footer-data-provider.js";
+export { convertToLlm } from "./core/messages.js";
+export { ModelRegistry } from "./core/model-registry.js";
+export type { PackageManager, PathMetadata, ProgressCallback, ProgressEvent, ResolvedPaths, ResolvedResource, } from "./core/package-manager.js";
+export { DefaultPackageManager } from "./core/package-manager.js";
+export type { ResourceCollision, ResourceDiagnostic, ResourceLoader } from "./core/resource-loader.js";
+export { DefaultResourceLoader } from "./core/resource-loader.js";
+export { type CreateAgentSessionOptions, type CreateAgentSessionResult, createAgentSession, createBashTool, createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createReadOnlyTools, createReadTool, createWriteTool, type PromptTemplate, readOnlyTools, } from "./core/sdk.js";
+export { type BranchSummaryEntry, buildSessionContext, type CompactionEntry, CURRENT_SESSION_VERSION, type CustomEntry, type CustomMessageEntry, type FileEntry, getLatestCompactionEntry, type ModelChangeEntry, migrateSessionEntries, type NewSessionOptions, parseSessionEntries, type SessionContext, type SessionEntry, type SessionEntryBase, type SessionHeader, type SessionInfo, type SessionInfoEntry, SessionManager, type SessionMessageEntry, type ThinkingLevelChangeEntry, } from "./core/session-manager.js";
+export { type CompactionSettings, type ImageSettings, type PackageSource, type RetrySettings, SettingsManager, } from "./core/settings-manager.js";
+export { formatSkillsForPrompt, type LoadSkillsFromDirOptions, type LoadSkillsResult, loadSkills, loadSkillsFromDir, type Skill, type SkillFrontmatter, } from "./core/skills.js";
+export { type BashOperations, type BashSpawnContext, type BashSpawnHook, type BashToolDetails, type BashToolInput, type BashToolOptions, bashTool, codingTools, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, type EditOperations, type EditToolDetails, type EditToolInput, type EditToolOptions, editTool, type FindOperations, type FindToolDetails, type FindToolInput, type FindToolOptions, findTool, formatSize, type GrepOperations, type GrepToolDetails, type GrepToolInput, type GrepToolOptions, grepTool, type LsOperations, type LsToolDetails, type LsToolInput, type LsToolOptions, lsTool, type ReadOperations, type ReadToolDetails, type ReadToolInput, type ReadToolOptions, readTool, type ToolsOptions, type TruncationOptions, type TruncationResult, truncateHead, truncateLine, truncateTail, type WriteOperations, type WriteToolInput, type WriteToolOptions, writeTool, } from "./core/tools/index.js";
+export { main } from "./main.js";
+export { InteractiveMode, type InteractiveModeOptions, type PrintModeOptions, runPrintMode, runRpcMode, } from "./modes/index.js";
+export { ArminComponent, AssistantMessageComponent, appKey, appKeyHint, BashExecutionComponent, BorderedLoader, BranchSummaryMessageComponent, CompactionSummaryMessageComponent, CustomEditor, CustomMessageComponent, DynamicBorder, ExtensionEditorComponent, ExtensionInputComponent, ExtensionSelectorComponent, editorKey, FooterComponent, keyHint, LoginDialogComponent, ModelSelectorComponent, OAuthSelectorComponent, type RenderDiffOptions, rawKeyHint, renderDiff, SessionSelectorComponent, type SettingsCallbacks, type SettingsConfig, SettingsSelectorComponent, ShowImagesSelectorComponent, SkillInvocationMessageComponent, ThemeSelectorComponent, ThinkingSelectorComponent, ToolExecutionComponent, type ToolExecutionOptions, TreeSelectorComponent, truncateToVisualLines, UserMessageComponent, UserMessageSelectorComponent, type VisualTruncateResult, } from "./modes/interactive/components/index.js";
+export { getLanguageFromPath, getMarkdownTheme, getSelectListTheme, getSettingsListTheme, highlightCode, initTheme, Theme, type ThemeColor, } from "./modes/interactive/theme/theme.js";
+export { copyToClipboard } from "./utils/clipboard.js";
+export { parseFrontmatter, stripFrontmatter } from "./utils/frontmatter.js";
+export { getShellConfig } from "./utils/shell.js";
+//# sourceMappingURL=index.d.ts.map