@draht/coding-agent 2026.3.2 → 2026.3.4

package/prompts/commands/new-project.md

@@ -8,11 +8,11 @@ Initialize a new GSD project: questioning → research → requirements → road
 ```
 
 ## Steps
-1. Run `draht init` to check preconditions
-2. If existing code detected, run `draht map-codebase` first
+1. Run `draht-tools init` to check preconditions
+2. If existing code detected, run `draht-tools map-codebase` first
 3. Deep questioning phase (3-7 rounds, 1-2 questions at a time)
-4. Run `draht create-project` with gathered info
-5. Run `draht create-domain-model` to define bounded contexts, entities, and ubiquitous language
+4. Run `draht-tools create-project` with gathered info
+5. Run `draht-tools create-domain-model` to define bounded contexts, entities, and ubiquitous language
 6. Create `.planning/DOMAIN.md` with:
    - `## Bounded Contexts` — each context with name, responsibility, and brief description
    - `## Ubiquitous Language` — glossary of domain terms agreed with the user (term → definition)
@@ -25,11 +25,11 @@ Initialize a new GSD project: questioning → research → requirements → road
    - `## Coverage Goals` — target coverage percentage and which paths are critical
    - `## Testing Levels` — what is tested at unit level vs integration vs e2e, with examples
    - `## Excluded` — what is explicitly not tested and why (config files, generated code, etc.)
-8. Optional research phase via `draht research`
-9. Run `draht create-requirements` with v1/v2/out-of-scope (map requirements to bounded contexts)
-10. Run `draht create-roadmap` with phases
-11. Run `draht init-state`
-12. Git commit via `draht commit-docs "initialize GSD project"`
+8. Optional research phase via `draht-tools research`
+9. Run `draht-tools create-requirements` with v1/v2/out-of-scope (map requirements to bounded contexts)
+10. Run `draht-tools create-roadmap` with phases
+11. Run `draht-tools init-state`
+12. Git commit via `draht-tools commit-docs "initialize GSD project"`
 
 ## Rules
 - Ask 1-2 questions at a time, never dump 10 at once

package/prompts/commands/next-milestone.md

@@ -0,0 +1,44 @@
+# /next-milestone
+
+Plan the next milestone after the current one is complete.
+
+## Usage
+```
+/next-milestone
+```
+
+## Prerequisites
+- `.planning/ROADMAP.md` must exist
+- Current milestone should be complete or nearly complete
+
+## Steps
+1. Load project context:
+   - Read `.planning/ROADMAP.md` — identify the completed milestone and its phases
+   - Read `.planning/STATE.md` — understand current status
+   - Read `.planning/REQUIREMENTS.md` — check which requirements are satisfied
+   - Read `.planning/DOMAIN.md` (if exists) — review domain model for evolution needs
+2. Review completed work:
+   - Scan `.planning/phases/` for all UAT reports (`*-UAT.md`) and summaries (`*-SUMMARY.md`)
+   - Note what was built, what worked well, what had issues
+3. Assess requirements:
+   - Which v1 requirements are now satisfied?
+   - Which v1 requirements remain?
+   - Should any v2 requirements be promoted based on what we learned?
+   - Are there new requirements discovered during implementation?
+4. Propose next milestone:
+   - Define 3-5 phases, each with a clear goal (outcome, not activity)
+   - Order phases by dependency
+   - Map each phase to specific requirements
+   - Estimate relative complexity
+5. Present the proposed milestone for user approval before writing files
+6. After approval:
+   - Update `ROADMAP.md` with the new milestone and phases
+   - Update `STATE.md` to reflect milestone transition
+   - Update `REQUIREMENTS.md` if requirements changed
+   - Update `DOMAIN.md` if domain model needs evolution
+   - Commit: `draht-tools commit-docs "plan next milestone"`
+
+## Rules
+- Always review what was actually built, not just what was planned
+- Be honest about requirements that slipped or changed scope
+- Each phase goal must be testable — "user can X" not "implement Y"

package/prompts/commands/pause-work.md

@@ -8,5 +8,5 @@ Create a handoff document for session continuity.
 ```
 
 ## Steps
-1. Run `draht pause` — creates CONTINUE-HERE.md
-2. Commit: `draht commit-docs "pause work"`
+1. Run `draht-tools pause` — creates CONTINUE-HERE.md
+2. Commit: `draht-tools commit-docs "pause work"`

package/prompts/commands/plan-phase.md

@@ -8,17 +8,17 @@ Create atomic execution plans for a roadmap phase.
 ```
 
 ## Steps
-1. Run `draht load-phase-context N` to gather all context
-2. Optional: `draht research-phase N` for domain research
+1. Run `draht-tools load-phase-context N` to gather all context
+2. Optional: `draht-tools research-phase N` for domain research
 3. Goal-backward planning:
    a. State the goal (outcome, not activity)
    b. Derive observable truths (3-7 from user perspective)
    c. From each observable truth, derive the test scenarios that would prove it (specific inputs → expected outputs or state changes)
    d. Map to required artifacts (files, endpoints, schemas)
    e. Break into atomic tasks (2-5 per plan)
-4. Write plans: `draht create-plan N P`
-5. Validate: `draht validate-plans N`
-6. Commit: `draht commit-docs "create phase N plans"`
+4. Write plans: `draht-tools create-plan N P`
+5. Validate: `draht-tools validate-plans N`
+6. Commit: `draht-tools commit-docs "create phase N plans"`
 
 ## Plan Format
 Plans use XML task format:

package/prompts/commands/progress.md

@@ -8,5 +8,5 @@ Show current project status.
 ```
 
 ## Steps
-1. Run `draht progress` — outputs formatted status
+1. Run `draht-tools progress` — outputs formatted status
 2. Display the result as-is

package/prompts/commands/quick.md

@@ -8,12 +8,12 @@ Execute a small ad-hoc task with GSD tracking.
 ```
 
 ## Steps
-1. Run `draht next-quick-number` to get task number
-2. Create quick plan: `draht create-quick-plan NNN "description"`
+1. Run `draht-tools next-quick-number` to get task number
+2. Create quick plan: `draht-tools create-quick-plan NNN "description"`
 3. Execute tasks following the TDD cycle:
    - **🔴 RED** — Write a failing test that describes the desired behaviour
    - **🟢 GREEN** — Write the minimum implementation to make it pass
    - **🔵 REFACTOR** — Clean up while keeping the test green
    - *Exception: skip the TDD cycle only for pure config or documentation-only tasks that have no testable behaviour*
-4. Write summary: `draht write-quick-summary NNN`
-5. Update state: `draht update-state`
+4. Write summary: `draht-tools write-quick-summary NNN`
+5. Update state: `draht-tools update-state`

package/prompts/commands/resume-work.md

@@ -8,6 +8,6 @@ Resume from last session state.
 ```
 
 ## Steps
-1. Run `draht resume` — loads CONTINUE-HERE.md or STATE.md
+1. Run `draht-tools resume` — loads CONTINUE-HERE.md or STATE.md
 2. Display context and ask to continue
 3. Delete CONTINUE-HERE.md after confirmation

package/prompts/commands/review.md

@@ -0,0 +1,26 @@
+# /review
+
+Ad-hoc code review and security audit of recent changes or a specific scope.
+
+## Usage
+```
+/review [scope]
+```
+
+If no scope given, reviews all recent uncommitted changes.
+
+## Steps
+1. Identify the scope:
+   - If argument given: review those files/directories/description
+   - If no argument: run `git diff --stat` and `git diff --cached --stat` to find changes
+2. For each changed file, examine:
+   - Correctness: logic errors, off-by-one, null handling, error paths
+   - Type safety: any `as` casts, `any` types, missing null checks
+   - Conventions: naming, file organization, import style
+   - Security: injection risks, auth bypasses, secrets in code, unsafe deserialization
+   - Performance: unnecessary allocations, missing indexes, N+1 queries
+3. Produce a prioritized findings report:
+   - **Critical** — must fix before merge (security, data loss, crashes)
+   - **Important** — should fix (bugs, type issues, missing error handling)
+   - **Minor** — style, naming, or optional improvements
+4. For each finding: cite the exact file and line, explain the issue, suggest the fix

package/prompts/commands/verify-work.md

@@ -15,13 +15,13 @@ Walk through acceptance testing of completed phase work.
    - Load `.planning/DOMAIN.md` and extract all defined terms
    - Scan source files for PascalCase identifiers not present in the glossary
    - Flag any bounded context boundary violations (cross-context direct imports)
-3. Run quality gate: `draht quality-gate --strict`
-4. Run `draht extract-deliverables N` to get testable items
+3. Run quality gate: `draht-tools quality-gate --strict`
+4. Run `draht-tools extract-deliverables N` to get testable items
 5. Walk user through each deliverable one at a time
 6. Record results (pass/fail/partially/skip)
-7. For failures: diagnose and create fix plans via `draht create-fix-plan N P`
+7. For failures: diagnose and create fix plans via `draht-tools create-fix-plan N P`
    - Fix plans MUST include a reproducing test that demonstrates the failure before any implementation
-8. Write UAT report: `draht write-uat N`
+8. Write UAT report: `draht-tools write-uat N`
    - Report must include: test health summary (pass/fail/coverage), domain model status (any glossary violations), deliverable results
 9. If all passed: mark phase complete
 10. If failures: route to `execute-phase N --gaps-only`

package/dist/extensions/gsd-commands.ts

@@ -1,338 +0,0 @@
-/**
- * GSD — Get Shit Done
- *
- * Batteries-included phase commands for structured AI-assisted development.
- *
- * Full workflow:
- *   /discuss <feature>          — clarify requirements before planning
- *   /plan    <feature>          — architect produces implementation plan
- *   /execute <task1, task2...>  — parallel implement → review → commit
- *   /verify                     — parallel lint/typecheck/tests + security audit
- *
- * Utilities:
- *   /review  <scope>            — ad-hoc code review + security audit
- *   /fix     <issue>            — targeted fix plan for a failing task
- *   /quick   <task>             — one-shot implement + commit (skip full GSD)
- *   /resume                     — pick up interrupted work from CONTINUE-HERE.md
- *   /status                     — show .planning/STATE.md overview
- *   /new-project <name> [path]  — create project dir, git init, scaffold .draht/
- *   /init-project               — scaffold .draht/ in existing project
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { ExtensionAPI } from "@draht/coding-agent";
-
-function isBusy(ctx: { isIdle: () => boolean }, ui: { notify: (msg: string, level: string) => void }): boolean {
-	if (!ctx.isIdle()) {
-		ui.notify("Agent is busy", "warning");
-		return true;
-	}
-	return false;
-}
-
-export default function (pi: ExtensionAPI) {
-	// ── /discuss ─────────────────────────────────────────────────────────────
-	pi.registerCommand("discuss", {
-		description: "Clarify requirements before planning. Architect asks questions and defines scope. Usage: /discuss <feature>",
-		handler: async (args, ctx) => {
-			if (!args.trim()) {
-				ctx.ui.notify("Usage: /discuss <feature description>", "warning");
-				return;
-			}
-			if (isBusy(ctx, ctx.ui)) return;
-
-			pi.sendUserMessage(
-				`Use the subagent tool to delegate to the architect agent with this task:
-
-"We are in the DISCUSS phase for: ${args.trim()}
-
-Your job is NOT to plan yet. First:
-1. Read relevant existing code to understand the current state
-2. Identify ambiguities, unknowns, and risks
-3. List clarifying questions that need answers before planning can begin
-4. Define a clear, bounded scope for what will and won't be built
-5. Output a DISCUSS summary with: scope, assumptions, open questions, risks
-
-Do not produce file lists or implementation details yet."
-
-Set agentScope to "project".`,
-			);
-		},
-	});
-
-	// ── /plan ────────────────────────────────────────────────────────────────
-	pi.registerCommand("plan", {
-		description: "Plan a feature — architect reads codebase and produces structured implementation plan. Usage: /plan <feature>",
-		handler: async (args, ctx) => {
-			if (!args.trim()) {
-				ctx.ui.notify("Usage: /plan <feature description>", "warning");
-				return;
-			}
-			if (isBusy(ctx, ctx.ui)) return;
-
-			pi.sendUserMessage(
-				`Use the subagent tool to delegate to the architect agent with this task: "${args.trim()}"\n\nSet agentScope to "project".`,
-			);
-		},
-	});
-
-	// ── /execute ─────────────────────────────────────────────────────────────
-	pi.registerCommand("execute", {
-		description: "Execute tasks in parallel, then chain reviewer + git-committer. Usage: /execute task1, task2, task3",
-		handler: async (args, ctx) => {
-			if (!args.trim()) {
-				ctx.ui.notify("Usage: /execute task1, task2, task3", "warning");
-				return;
-			}
-			if (isBusy(ctx, ctx.ui)) return;
-
-			const tasks = args.split(",").map((t) => t.trim()).filter(Boolean);
-
-			if (tasks.length === 1) {
-				pi.sendUserMessage(
-					`Use the subagent tool in chain mode with agentScope "project":
-1. agent: implementer — task: "${tasks[0]}"
-2. agent: reviewer    — task: "Review the changes just made: {previous}"
-3. agent: git-committer — task: "Commit all changes. Review context: {previous}"`,
-				);
-			} else {
-				const parallelList = tasks.map((t, i) => `${i + 1}. agent: implementer — task: "${t}"`).join("\n");
-				pi.sendUserMessage(
-					`Use the subagent tool with agentScope "project":
-
-Step 1 — PARALLEL mode (run all simultaneously):
-${parallelList}
-
-Step 2 — CHAIN mode (after all parallel tasks complete):
-1. agent: reviewer      — task: "Review all changes just implemented"
-2. agent: git-committer — task: "Commit all changes. Review findings: {previous}"`,
-				);
-			}
-		},
-	});
-
-	// ── /verify ──────────────────────────────────────────────────────────────
-	pi.registerCommand("verify", {
-		description: "Parallel verification: lint, typecheck, tests, and security audit",
-		handler: async (_args, ctx) => {
-			if (isBusy(ctx, ctx.ui)) return;
-
-			pi.sendUserMessage(
-				`Use the subagent tool in PARALLEL mode with agentScope "project":
-1. agent: verifier        — task: "Run all lint, typecheck, and test checks"
-2. agent: security-auditor — task: "Audit all recent changes for security vulnerabilities"
-
-After both complete, merge findings into a single prioritized report. List what must be fixed before this is production-ready.`,
-			);
-		},
-	});
-
-	// ── /review ──────────────────────────────────────────────────────────────
-	pi.registerCommand("review", {
-		description: "Ad-hoc code review + security audit. Usage: /review <scope or files>",
-		handler: async (args, ctx) => {
-			if (isBusy(ctx, ctx.ui)) return;
-
-			const scope = args.trim() || "all recent changes";
-			pi.sendUserMessage(
-				`Use the subagent tool in PARALLEL mode with agentScope "project":
-1. agent: reviewer        — task: "Review ${scope} for correctness, type safety, and conventions"
-2. agent: security-auditor — task: "Audit ${scope} for security vulnerabilities"
-
-After both complete, merge into a single prioritized findings report.`,
-			);
-		},
-	});
-
-	// ── /fix ─────────────────────────────────────────────────────────────────
-	pi.registerCommand("fix", {
-		description: "Create a targeted fix plan for a failing task or bug. Usage: /fix <description of what's broken>",
-		handler: async (args, ctx) => {
-			if (!args.trim()) {
-				ctx.ui.notify("Usage: /fix <description of what's broken>", "warning");
-				return;
-			}
-			if (isBusy(ctx, ctx.ui)) return;
-
-			pi.sendUserMessage(
-				`Use the subagent tool in chain mode with agentScope "project":
-1. agent: architect  — task: "Diagnose this issue and produce a minimal fix plan: ${args.trim()}. Read the relevant code first. Output: root cause, exact files to change, fix steps."
-2. agent: implementer — task: "Apply this fix plan exactly: {previous}"
-3. agent: reviewer    — task: "Verify the fix is correct and doesn't introduce regressions: {previous}"
-4. agent: git-committer — task: "Commit the fix. Fix summary: {previous}"`,
-			);
-		},
-	});
-
-	// ── /quick ───────────────────────────────────────────────────────────────
-	pi.registerCommand("quick", {
-		description: "One-shot task: implement + commit. Skips full GSD workflow. Usage: /quick <task>",
-		handler: async (args, ctx) => {
-			if (!args.trim()) {
-				ctx.ui.notify("Usage: /quick <task description>", "warning");
-				return;
-			}
-			if (isBusy(ctx, ctx.ui)) return;
-
-			pi.sendUserMessage(
-				`Use the subagent tool in chain mode with agentScope "project":
-1. agent: implementer   — task: "${args.trim()}"
-2. agent: git-committer — task: "Commit the changes just made: {previous}"`,
-			);
-		},
-	});
-
-	// ── /resume ──────────────────────────────────────────────────────────────
-	pi.registerCommand("resume", {
-		description: "Resume interrupted work — reads CONTINUE-HERE.md and picks up where we left off",
-		handler: async (_args, ctx) => {
-			if (isBusy(ctx, ctx.ui)) return;
-
-			const continueFile = path.join(ctx.cwd, ".planning", "CONTINUE-HERE.md");
-			const stateFile = path.join(ctx.cwd, ".planning", "STATE.md");
-
-			if (!fs.existsSync(continueFile) && !fs.existsSync(stateFile)) {
-				ctx.ui.notify("No .planning/CONTINUE-HERE.md or STATE.md found. Nothing to resume.", "warning");
-				return;
-			}
-
-			let context = "";
-			if (fs.existsSync(continueFile)) {
-				context += `\nCONTINUE-HERE.md:\n${fs.readFileSync(continueFile, "utf-8")}`;
-			}
-			if (fs.existsSync(stateFile)) {
-				context += `\nSTATE.md:\n${fs.readFileSync(stateFile, "utf-8")}`;
-			}
-
-			pi.sendUserMessage(
-				`Read the following project state and resume work from where it was interrupted. Identify the next incomplete task and proceed with it using the appropriate subagent.${context}`,
-			);
-		},
-	});
-
-	// ── /status ──────────────────────────────────────────────────────────────
-	pi.registerCommand("status", {
-		description: "Show current GSD project state from .planning/STATE.md",
-		handler: async (_args, ctx) => {
-			const stateFile = path.join(ctx.cwd, ".planning", "STATE.md");
-			const logFile = path.join(ctx.cwd, ".planning", "execution-log.jsonl");
-
-			if (!fs.existsSync(stateFile)) {
-				ctx.ui.notify("No .planning/STATE.md found. Run /init-project or /new-project first.", "warning");
-				return;
-			}
-
-			let output = fs.readFileSync(stateFile, "utf-8");
-
-			if (fs.existsSync(logFile)) {
-				const entries = fs.readFileSync(logFile, "utf-8")
-					.split("\n").filter(Boolean)
-					.map((l) => { try { return JSON.parse(l); } catch { return null; } })
-					.filter(Boolean);
-
-				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;
-				output += `\n\n---\n**Execution log:** ${passed} passed, ${failed} failed, ${skipped} skipped`;
-			}
-
-			pi.sendUserMessage(`Here is the current project state:\n\n${output}`);
-		},
-	});
-
-	// ── /new-project ─────────────────────────────────────────────────────────
-	pi.registerCommand("new-project", {
-		description: "Create a new project: mkdir, git init, scaffold .draht/. Usage: /new-project <name> [/base/path]",
-		handler: async (args, ctx) => {
-			const parts = args.trim().split(/\s+/);
-			const name = parts[0];
-			if (!name) {
-				ctx.ui.notify("Usage: /new-project <name> [/optional/base/path]", "warning");
-				return;
-			}
-
-			const basePath = parts[1] ?? ctx.cwd;
-			const projectDir = path.join(basePath, name);
-
-			if (fs.existsSync(projectDir)) {
-				ctx.ui.notify(`Directory already exists: ${projectDir}`, "warning");
-				return;
-			}
-
-			fs.mkdirSync(projectDir, { recursive: true });
-
-			const { execSync } = await import("node:child_process");
-			execSync("git init", { cwd: projectDir });
-
-			// Scaffold .draht/ from global agents
-			const agentSrc = path.join(process.env.HOME ?? "~", ".draht", "agent", "agents");
-			const agentDest = path.join(projectDir, ".draht", "agents");
-			const extDest = path.join(projectDir, ".draht", "extensions");
-			fs.mkdirSync(agentDest, { recursive: true });
-			fs.mkdirSync(extDest, { recursive: true });
-
-			let agentsCopied = 0;
-			if (fs.existsSync(agentSrc)) {
-				for (const file of fs.readdirSync(agentSrc)) {
-					if (!file.endsWith(".md")) continue;
-					fs.copyFileSync(path.join(agentSrc, file), path.join(agentDest, file));
-					agentsCopied++;
-				}
-			}
-
-			// Copy shipped extensions into the new project
-			const extSrc = path.dirname(new URL(import.meta.url).pathname);
-			for (const file of ["subagent.ts", "gsd-commands.ts"]) {
-				const src = path.join(extSrc, file);
-				if (fs.existsSync(src)) {
-					fs.copyFileSync(src, path.join(extDest, file));
-				}
-			}
-
-			fs.writeFileSync(path.join(projectDir, ".gitignore"), "node_modules/\n.env\n.env.local\n");
-
-			ctx.ui.notify(
-				`✓ ${projectDir} created — ${agentsCopied} agents, git initialized. Customize .draht/agents/*.md for your stack.`,
-				"info",
-			);
-
-			pi.sendUserMessage(
-				`New project "${name}" created at ${projectDir} with ${agentsCopied} GSD agents scaffolded. What should we build first?`,
-			);
-		},
-	});
-
-	// ── /init-project ────────────────────────────────────────────────────────
-	pi.registerCommand("init-project", {
-		description: "Scaffold .draht/ config into an existing project from global agent defaults",
-		handler: async (_args, ctx) => {
-			const targetDir = path.join(ctx.cwd, ".draht");
-
-			if (fs.existsSync(targetDir)) {
-				ctx.ui.notify(".draht/ already exists in this project", "warning");
-				return;
-			}
-
-			const agentSrc = path.join(process.env.HOME ?? "~", ".draht", "agent", "agents");
-			const agentDest = path.join(targetDir, "agents");
-			const extDest = path.join(targetDir, "extensions");
-			fs.mkdirSync(agentDest, { recursive: true });
-			fs.mkdirSync(extDest, { recursive: true });
-
-			let copied = 0;
-			if (fs.existsSync(agentSrc)) {
-				for (const file of fs.readdirSync(agentSrc)) {
-					if (!file.endsWith(".md")) continue;
-					fs.copyFileSync(path.join(agentSrc, file), path.join(agentDest, file));
-					copied++;
-				}
-			}
-
-			ctx.ui.notify(
-				`.draht/ scaffolded with ${copied} agents. Customize .draht/agents/*.md for this project's stack.`,
-				"info",
-			);
-		},
-	});
-}