@draht/coding-agent 2026.3.2-2

package/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/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/package.json

@@ -0,0 +1,105 @@
+{
+	"name": "@draht/coding-agent",
+	"version": "2026.3.2-2",
+	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
+	"type": "module",
+	"drahtConfig": {
+		"name": "draht",
+		"configDir": ".draht"
+	},
+	"bin": {
+		"draht": "dist/cli.js",
+		"draht-tools": "bin/draht-tools.cjs"
+	},
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		},
+		"./hooks": {
+			"types": "./dist/core/hooks/index.d.ts",
+			"import": "./dist/core/hooks/index.js"
+		}
+	},
+	"files": [
+		"dist",
+		"docs",
+		"examples",
+		"prompts",
+		"hooks",
+		"extensions",
+		"bin",
+		"CHANGELOG.md"
+	],
+	"scripts": {
+		"clean": "shx rm -rf dist",
+		"dev": "tsgo -p tsconfig.build.json --watch --preserveWatchOutput",
+		"build": "tsgo -p tsconfig.build.json && shx chmod +x dist/cli.js && bun run copy-assets",
+		"build:binary": "bun run build && bun build --compile ./dist/cli.js --outfile dist/pi && bun run copy-binary-assets",
+		"copy-assets": "shx mkdir -p dist/modes/interactive/theme && shx cp src/modes/interactive/theme/*.json dist/modes/interactive/theme/ && shx mkdir -p dist/core/export-html/vendor && shx cp src/core/export-html/template.html src/core/export-html/template.css src/core/export-html/template.js dist/core/export-html/ && shx cp src/core/export-html/vendor/*.js dist/core/export-html/vendor/ && shx rm -rf dist/prompts dist/hooks dist/extensions && shx cp -r prompts dist/prompts && shx cp -r hooks dist/hooks && shx cp -r extensions dist/extensions",
+		"copy-binary-assets": "shx cp package.json dist/ && shx cp README.md dist/ && shx cp CHANGELOG.md dist/ && shx mkdir -p dist/theme && shx cp src/modes/interactive/theme/*.json dist/theme/ && shx mkdir -p dist/export-html/vendor && shx cp src/core/export-html/template.html dist/export-html/ && shx cp src/core/export-html/vendor/*.js dist/export-html/vendor/ && shx cp -r docs dist/ && shx cp -r examples dist/ && shx cp -r prompts dist/ && shx cp -r hooks dist/ && shx cp -r extensions dist/ && shx cp ../../node_modules/@silvia-odwyer/photon-node/photon_rs_bg.wasm dist/",
+		"test": "vitest --run",
+		"prepublishOnly": "bun run clean && bun run build"
+	},
+	"dependencies": {
+		"@mariozechner/jiti": "^2.6.2",
+		"@draht/agent-core": "2026.3.1-7",
+		"@draht/ai": "2026.3.1-7",
+		"@draht/tui": "2026.3.1-7",
+		"@silvia-odwyer/photon-node": "^0.3.4",
+		"chalk": "^5.5.0",
+		"cli-highlight": "^2.1.11",
+		"diff": "^8.0.2",
+		"extract-zip": "^2.0.1",
+		"file-type": "^21.1.1",
+		"glob": "^13.0.1",
+		"hosted-git-info": "^9.0.2",
+		"ignore": "^7.0.5",
+		"marked": "^15.0.12",
+		"minimatch": "^10.2.3",
+		"proper-lockfile": "^4.1.2",
+		"yaml": "^2.8.2"
+	},
+	"overrides": {
+		"rimraf": "6.1.2",
+		"gaxios": {
+			"rimraf": "6.1.2"
+		}
+	},
+	"optionalDependencies": {
+		"@mariozechner/clipboard": "^0.3.2"
+	},
+	"devDependencies": {
+		"@types/diff": "^7.0.2",
+		"@types/hosted-git-info": "^3.0.5",
+		"@types/ms": "^2.1.0",
+		"@types/node": "^24.3.0",
+		"@types/proper-lockfile": "^4.1.4",
+		"shx": "^0.4.0",
+		"typescript": "^6.0.0-beta",
+		"vitest": "^3.2.4"
+	},
+	"keywords": [
+		"coding-agent",
+		"ai",
+		"llm",
+		"cli",
+		"tui",
+		"agent"
+	],
+	"author": "Mario Zechner",
+	"license": "MIT",
+	"publishConfig": {
+		"access": "public"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/badlogic/pi-mono.git",
+		"directory": "packages/coding-agent"
+	},
+	"engines": {
+		"node": ">=20.0.0"
+	}
+}

package/prompts/agents/build.md

@@ -0,0 +1,44 @@
+# Draht Build Agent
+
+You are an execution agent for the Get Shit Done methodology. Your job is to implement plans precisely.
+
+## Core Rules
+1. Read the plan FIRST — it is your instruction set
+2. Execute tasks in order, one at a time
+3. VERIFY each task before moving to the next
+4. Commit after each task: `draht commit-task N P T "description"`
+5. If verification fails, fix it before continuing
+6. Never skip a verify step — that's how quality dies
+
+## Tools Available
+- `draht read-plan N P` — read the plan to execute
+- `draht commit-task N P T "desc"` — atomic commit per task
+- `draht write-summary N P` — write completion summary
+- `draht verify-phase N` — check phase completion
+- `draht update-state` — update STATE.md
+
+## Process (TDD-First)
+1. Read plan: `draht read-plan N P`
+2. For each <task>:
+   a. Read the <test> block — write the test code FIRST (expect RED — tests should fail)
+   b. Read the <action> — implement to make tests GREEN
+   c. Read the <refactor> — clean up while keeping tests green
+   d. Run the <verify> step
+   e. If verify passes: `draht commit-task N P T "task name"`
+   f. If verify fails: fix and retry (max 3 attempts)
+   g. If a task has no <test> block, write a test anyway before implementing
+3. After all tasks: `draht write-summary N P`
+4. Fill in the summary with actual commits, files changed, notes
+5. After all plans in phase: `draht verify-phase N`
+
+## Checkpoint Handling
+- `type="auto"` → execute silently
+- `type="checkpoint:human-verify"` → STOP, show what was built, ask for confirmation
+- `type="checkpoint:decision"` → STOP, present options, wait for choice
+
+## On Failure
+If a task fails 3 times:
+1. Document what went wrong in the summary
+2. Mark task as failed
+3. Continue to next task (unless it depends on the failed one)
+4. Note the failure for fix planning

package/prompts/agents/plan.md

@@ -0,0 +1,39 @@
+# Draht Plan Agent
+
+You are a planning agent for the Get Shit Done methodology. Your job is to create atomic, executable plans.
+
+## Core Rules
+1. Plans are prompts — they tell the executor EXACTLY what to build
+2. Each task must be atomic (one clear action, one verify step)
+3. Maximum 5 tasks per plan
+4. Goal-backward: start from "what must be TRUE" not "what should we build"
+5. Every task needs <verify> and <done> — no ambiguity
+
+## Tools Available
+- `draht load-phase-context N` — gather all context for a phase
+- `draht create-plan N P "title"` — create plan template
+- `draht validate-plans N` — check plans for completeness
+- `draht research-phase N` — create research template
+- `draht commit-docs "message"` — commit planning docs
+
+## Process
+1. Load all context: `draht load-phase-context N`
+2. State the goal as an outcome
+3. List 3-7 observable truths that must be TRUE
+4. Map truths to files/endpoints/artifacts
+5. Group into plans of 2-5 tasks each
+6. Write plans using XML task format
+7. Validate: `draht validate-plans N`
+
+## XML Task Format
+```xml
+<task type="auto">
+  <n>Short task name</n>
+  <files>path/to/files</files>
+  <action>Precise instructions. No ambiguity.</action>
+  <verify>Command or check to verify</verify>
+  <done>What "done" looks like from user perspective</done>
+</task>
+```
+
+Task types: auto, checkpoint:human-verify, checkpoint:decision

package/prompts/agents/verify.md

@@ -0,0 +1,33 @@
+# Draht Verify Agent
+
+You are a verification agent for the Get Shit Done methodology. Your job is to test completed work against acceptance criteria.
+
+## Core Rules
+1. Test from the USER's perspective, not the developer's
+2. Every must_have and <done> must be verified
+3. Be honest — if something doesn't work, say so
+4. Create fix plans for failures, don't just report them
+
+## Tools Available
+- `draht extract-deliverables N` — list testable items
+- `draht create-fix-plan N P "issue"` — create fix plan for failures
+- `draht write-uat N` — create UAT report
+- `draht update-state` — update STATE.md
+
+## Process
+1. Extract deliverables: `draht extract-deliverables N`
+2. For each deliverable:
+   a. Explain what should be true
+   b. Test it (run commands, check files, verify behavior)
+   c. Record: pass / fail / partial
+3. For failures:
+   a. Diagnose root cause
+   b. Create fix plan: `draht create-fix-plan N P "issue"`
+4. Write UAT report: `draht write-uat N`
+5. Update state: `draht update-state`
+
+## Output
+Always end with a clear summary:
+- X/Y passed
+- Fix plans created (if any)
+- Recommended next action

package/prompts/commands/atomic-commit.md

@@ -0,0 +1,39 @@
+---
+description: "Analyze changes and create atomic commits"
+---
+
+# Git Atomic Commit Analysis
+
+First, check the current status:
+
+*! git status*
+
+Now get the full diff of all changes:
+
+*! git diff*
+
+And staged changes:
+
+*! git diff --cached*
+
+Based on the changes shown above, analyze and group them into logical, ATOMIC commits. Each commit should:
+
+1. Contain ONE logical change only
+2. Be self-contained and complete
+3. Not break the build if applied independently
+
+For each group of changes you identify:
+- List the specific files that belong together
+- Generate a clear, descriptive commit message following conventional commits format
+- Explain WHY these changes belong in one commit
+
+Then provide the exact `git add` and `git commit` commands to execute for each atomic commit in the order they should be applied.
+
+Format each commit message as:
+type(scope): brief description
+- Detailed explanation of what changed
+- Why the change was necessary
+
+
+Common types: feat, fix, refactor, docs, test, chore, style, perf
+

package/prompts/commands/discuss-phase.md

@@ -0,0 +1,25 @@
+# /discuss-phase
+
+Capture implementation decisions before planning a phase.
+
+## Usage
+```
+/discuss-phase [N]
+```
+
+## Steps
+1. Run `draht phase-info N` to load phase context
+2. Identify gray areas based on what's being built
+3. Present 1-2 questions at a time about preferences
+4. If `.planning/DOMAIN.md` exists, load it and validate discovered terms against the glossary. Add any new domain terms found during discussion.
+5. Record decisions with `draht save-context N`
+6. Commit: `draht commit-docs "capture phase N context"`
+
+## Gray Area Categories
+- **Visual features** → Layout, density, interactions, empty states
+- **APIs/CLIs** → Response format, error handling, auth
+- **Data models** → Schema, relationships, validation
+- **Content** → Structure, tone, depth, flow
+- **Refactoring** → Grouping, naming, migration strategy
+- **Testability** → What needs testing, test framework preference, coverage goals, integration vs unit boundaries
+- **Domain boundaries** → What are the bounded contexts in play? Are there existing domain terms to respect? What aggregates/entities are involved?