@draht/coding-agent 2026.3.2 → 2026.3.3

package/extensions/subagent.ts

@@ -16,13 +16,18 @@ import * as os from "node:os";
 import * as path from "node:path";
 import type { Message } from "@draht/ai";
 import { StringEnum } from "@draht/ai";
-import { type ExtensionAPI, getAgentDir, parseFrontmatter } from "@draht/coding-agent";
+import { type ExtensionAPI, getAgentDir, getPackageDir, isBunBinary, parseFrontmatter } from "@draht/coding-agent";
+import { Text } from "@draht/tui";
 import { Type } from "@sinclair/typebox";
 
 const MAX_PARALLEL = 8;
 const MAX_CONCURRENCY = 4;
-// Use the same binary that's currently running
+
+// Build the command to spawn a subagent process.
+// Compiled Bun binary: process.execPath IS the CLI binary, args go directly.
+// Source/dev mode: process.execPath is the runtime (bun/node), process.argv[1] is the CLI script.
 const DRAHT_BIN = process.execPath;
+const DRAHT_ARGS_PREFIX: string[] = isBunBinary ? [] : [process.argv[1]];
 
 // ─── Agent discovery ────────────────────────────────────────────────────────
 
@@ -82,13 +87,20 @@ function findProjectAgentsDir(cwd: string): string | null {
 type AgentScope = "user" | "project" | "both";
 
 function discoverAgents(cwd: string, scope: AgentScope): AgentConfig[] {
+	// Shipped agents (bundled with the package) — lowest priority
+	const shippedDir = path.join(getPackageDir(), "agents");
+	const shippedAgents = loadAgentsFromDir(shippedDir, "user");
+
 	const userDir = path.join(getAgentDir(), "agents");
 	const projectDir = findProjectAgentsDir(cwd);
 	const userAgents = scope !== "project" ? loadAgentsFromDir(userDir, "user") : [];
 	const projectAgents = scope !== "user" && projectDir ? loadAgentsFromDir(projectDir, "project") : [];
+
+	// Priority: shipped < user < project
 	const map = new Map<string, AgentConfig>();
+	for (const a of shippedAgents) map.set(a.name, a);
 	for (const a of userAgents) map.set(a.name, a);
-	for (const a of projectAgents) map.set(a.name, a); // project overrides global
+	for (const a of projectAgents) map.set(a.name, a);
 	return Array.from(map.values());
 }
 
@@ -127,12 +139,15 @@ function getFinalText(messages: Message[]): string {
 	return "";
 }
 
+type ProgressFn = (activity: string) => void;
+
 async function runAgent(
 	cwd: string,
 	agent: AgentConfig,
 	task: string,
 	signal?: AbortSignal,
 	step?: number,
+	onProgress?: ProgressFn,
 ): Promise<RunResult> {
 	const args: string[] = ["--mode", "json", "-p", "--no-session"];
 	if (agent.model) args.push("--model", agent.model);
@@ -155,7 +170,7 @@ async function runAgent(
 
 	try {
 		const exitCode = await new Promise<number>((resolve) => {
-			const proc = spawn(DRAHT_BIN, args, { cwd, shell: false, stdio: ["ignore", "pipe", "pipe"] });
+			const proc = spawn(DRAHT_BIN, [...DRAHT_ARGS_PREFIX, ...args], { cwd, shell: false, stdio: ["ignore", "pipe", "pipe"] });
 			let buf = "";
 
 			const processLine = (line: string) => {
@@ -165,6 +180,23 @@ async function runAgent(
 					if ((event.type === "message_end" || event.type === "tool_result_end") && event.message) {
 						messages.push(event.message as Message);
 					}
+					// Stream activity updates to the parent
+					if (onProgress) {
+						if (event.type === "tool_execution_start") {
+							const toolArgs = event.args ?? {};
+							const detail = toolArgs.command || toolArgs.path || toolArgs.file_path || toolArgs.pattern || "";
+							const short = typeof detail === "string" && detail.length > 60 ? `${detail.slice(0, 60)}...` : detail;
+							onProgress(short ? `${event.toolName} ${short}` : event.toolName);
+						} else if (event.type === "text_delta") {
+							// Show first line of streaming text as activity
+							const text = event.text?.trim();
+							if (text) {
+								const firstLine = text.split("\n")[0];
+								const short = firstLine.length > 80 ? `${firstLine.slice(0, 80)}...` : firstLine;
+								onProgress(short);
+							}
+						}
+					}
 				} catch {}
 			};
 
@@ -235,6 +267,17 @@ const Params = Type.Object({
 	),
 });
 
+// ─── Rendering helpers ──────────────────────────────────────────────────────
+
+function truncateTask(task: string, maxLen = 120): string {
+	const oneLine = task.replace(/\n/g, " ").trim();
+	return oneLine.length > maxLen ? `${oneLine.slice(0, maxLen)}...` : oneLine;
+}
+
+interface SubagentDetails {
+	status?: string;
+}
+
 export default function (pi: ExtensionAPI) {
 	pi.registerTool({
 		name: "subagent",
@@ -243,7 +286,72 @@ export default function (pi: ExtensionAPI) {
 			"Delegate to specialized agents. single: {agent,task} | parallel: {tasks:[]} | chain: {chain:[]} with {previous} placeholder. agentScope: 'both' (default) uses project .draht/agents/ + global.",
 		parameters: Params,
 
-		async execute(_id, params, signal, _onUpdate, ctx) {
+		renderCall(args, theme) {
+			const lines: string[] = [];
+
+			if (args.chain?.length) {
+				const agents = args.chain.map((s: { agent: string }) => s.agent).join(" -> ");
+				lines.push(theme.fg("toolTitle", theme.bold(`subagent chain`)) + " " + theme.fg("accent", agents));
+				for (let i = 0; i < args.chain.length; i++) {
+					const step = args.chain[i];
+					const prefix = theme.fg("muted", `  ${i + 1}.`);
+					lines.push(`${prefix} ${theme.fg("accent", step.agent)} ${theme.fg("toolOutput", truncateTask(step.task))}`);
+				}
+			} else if (args.tasks?.length) {
+				lines.push(theme.fg("toolTitle", theme.bold(`subagent parallel`)) + theme.fg("muted", ` (${args.tasks.length} tasks)`));
+				for (const t of args.tasks) {
+					lines.push(`  ${theme.fg("accent", t.agent)} ${theme.fg("toolOutput", truncateTask(t.task))}`);
+				}
+			} else if (args.agent) {
+				lines.push(
+					theme.fg("toolTitle", theme.bold("subagent")) +
+					" " +
+					theme.fg("accent", args.agent) +
+					(args.task ? " " + theme.fg("toolOutput", truncateTask(args.task)) : ""),
+				);
+			} else {
+				lines.push(theme.fg("toolTitle", theme.bold("subagent")));
+			}
+
+			return new Text(lines.join("\n"), 0, 0);
+		},
+
+		renderResult(result, options, theme) {
+			const status = result.details?.status;
+			const output = result.content
+				?.filter((c) => c.type === "text")
+				.map((c) => ("text" in c ? c.text : ""))
+				.join("\n") || "";
+
+			const lines: string[] = [];
+
+			if (status) {
+				lines.push(theme.fg("muted", status));
+			}
+
+			if (output.trim()) {
+				const trimmed = output.trim();
+				if (options.expanded || options.isPartial) {
+					// When expanded or during execution, show full activity log
+					for (const line of trimmed.split("\n")) {
+						lines.push(theme.fg("toolOutput", line));
+					}
+				} else {
+					// Collapsed final result — show preview
+					const allLines = trimmed.split("\n");
+					const previewLines = allLines.slice(0, 8);
+					lines.push(theme.fg("toolOutput", previewLines.join("\n")));
+					if (allLines.length > 8) {
+						lines.push(theme.fg("muted", `... (${allLines.length - 8} more lines)`));
+					}
+				}
+			}
+
+			if (lines.length === 0) return new Text("", 0, 0);
+			return new Text(lines.join("\n"), 0, 0);
+		},
+
+		async execute(_id, params, signal, onUpdate, ctx) {
 			const scope: AgentScope = (params.agentScope as AgentScope) ?? "both";
 			const agents = discoverAgents(ctx.cwd, scope);
 			const available = agents.map((a) => a.name).join(", ") || "none";
@@ -254,6 +362,22 @@ export default function (pi: ExtensionAPI) {
 				isError: true,
 			});
 
+			// Stream live activity from the subagent process
+			const activityLines: string[] = [];
+			const emitProgress = (agentName: string, activity?: string) => {
+				const status = activity ? `${agentName}: ${activity}` : `${agentName} working...`;
+				onUpdate?.({
+					content: [{ type: "text" as const, text: activityLines.join("\n") }],
+					details: { status },
+				});
+			};
+			const makeProgressFn = (agentName: string): ProgressFn => (activity) => {
+				// Keep a rolling log of recent activities
+				activityLines.push(`${agentName}: ${activity}`);
+				if (activityLines.length > 50) activityLines.splice(0, activityLines.length - 50);
+				emitProgress(agentName, activity);
+			};
+
 			// ── Chain mode ──
 			if (params.chain?.length) {
 				let previous = "";
@@ -262,8 +386,10 @@ export default function (pi: ExtensionAPI) {
 					const step = params.chain[i];
 					const agent = find(step.agent);
 					if (!agent) return notFound(step.agent);
+					activityLines.length = 0;
+					emitProgress(step.agent, `step ${i + 1}/${params.chain.length}`);
 					const task = step.task.replace(/\{previous\}/g, previous);
-					const result = await runAgent(ctx.cwd, agent, task, signal, i + 1);
+					const result = await runAgent(ctx.cwd, agent, task, signal, i + 1, makeProgressFn(step.agent));
 					results.push(result);
 					if (result.exitCode !== 0) {
 						return {
@@ -283,13 +409,16 @@ export default function (pi: ExtensionAPI) {
 				}
 				for (const t of params.tasks) { if (!find(t.agent)) return notFound(t.agent); }
 
+				const agentNames = params.tasks.map((t: { agent: string }) => t.agent).join(", ");
+				emitProgress(agentNames);
+
 				const results = await runParallel(params.tasks, MAX_CONCURRENCY, async (t, i) => {
-					return runAgent(ctx.cwd, find(t.agent)!, t.task, signal);
+					return runAgent(ctx.cwd, find(t.agent)!, t.task, signal, undefined, makeProgressFn(t.agent));
 				});
 
 				const ok = results.filter((r) => r.exitCode === 0).length;
 				const summary = results
-					.map((r) => `[${r.agent}] ${r.exitCode === 0 ? "✓" : "✗"} ${r.output.slice(0, 200)}`)
+					.map((r) => `[${r.agent}] ${r.exitCode === 0 ? "ok" : "fail"} ${r.output.slice(0, 200)}`)
 					.join("\n\n");
 				return { content: [{ type: "text" as const, text: `Parallel: ${ok}/${results.length} succeeded\n\n${summary}` }] };
 			}
@@ -298,7 +427,8 @@ export default function (pi: ExtensionAPI) {
 			if (params.agent && params.task) {
 				const agent = find(params.agent);
 				if (!agent) return notFound(params.agent);
-				const result = await runAgent(ctx.cwd, agent, params.task, signal);
+				emitProgress(params.agent);
+				const result = await runAgent(ctx.cwd, agent, params.task, signal, undefined, makeProgressFn(params.agent));
 				const isError = result.exitCode !== 0;
 				return {
 					content: [{ type: "text" as const, text: result.output || result.stderr || "(no output)" }],
@@ -309,4 +439,77 @@ export default function (pi: ExtensionAPI) {
 			return { content: [{ type: "text" as const, text: `Provide exactly one mode. Available agents: ${available}` }], isError: true };
 		},
 	});
+
+	// ── Agent selection for user prompts ─────────────────────────────────────
+
+	let selectedAgent: string | undefined;
+
+	function updateAgentStatus(ctx: { ui: { setStatus: (key: string, text: string | undefined) => void } }) {
+		ctx.ui.setStatus("agent", selectedAgent ? `agent: ${selectedAgent}` : undefined);
+	}
+
+	// /agent command — select an agent or clear selection
+	pi.registerCommand("agent", {
+		description: "Select an agent to handle your next prompts, or clear selection. Usage: /agent [name]",
+		handler: async (args, ctx) => {
+			const agents = discoverAgents(ctx.cwd, "both");
+
+			if (args.trim()) {
+				// Direct selection: /agent architect
+				const name = args.trim();
+				if (name === "none" || name === "off" || name === "clear") {
+					selectedAgent = undefined;
+					updateAgentStatus(ctx);
+					ctx.ui.notify("Agent cleared — prompts go to default model", "info");
+					return;
+				}
+				const agent = agents.find((a) => a.name === name);
+				if (!agent) {
+					const available = agents.map((a) => a.name).join(", ") || "none";
+					ctx.ui.notify(`Unknown agent "${name}". Available: ${available}`, "warning");
+					return;
+				}
+				selectedAgent = name;
+				updateAgentStatus(ctx);
+				ctx.ui.notify(`Agent set to "${name}" — your prompts will be handled by this agent`, "info");
+				return;
+			}
+
+			// Interactive selection
+			if (!ctx.hasUI) {
+				ctx.ui.notify("Usage: /agent <name> or /agent none", "warning");
+				return;
+			}
+
+			const options = ["(none — default model)", ...agents.map((a) => `${a.name} — ${a.description}`)];
+			const choice = await ctx.ui.select("Select agent for your prompts", options);
+			if (choice === undefined) return; // cancelled
+
+			if (choice === options[0]) {
+				selectedAgent = undefined;
+				updateAgentStatus(ctx);
+				ctx.ui.notify("Agent cleared", "info");
+			} else {
+				const name = choice.split(" — ")[0];
+				selectedAgent = name;
+				updateAgentStatus(ctx);
+				ctx.ui.notify(`Agent set to "${name}"`, "info");
+			}
+		},
+		getArgumentCompletions: (partial) => {
+			const agents = discoverAgents(process.cwd(), "both");
+			const names = ["none", ...agents.map((a) => a.name)];
+			return names.filter((n) => n.startsWith(partial));
+		},
+	});
+
+	// Intercept user input when an agent is selected
+	pi.on("input", (event) => {
+		if (!selectedAgent) return { action: "continue" as const };
+		// Don't intercept slash commands
+		if (event.text.startsWith("/") || event.text.startsWith("!")) return { action: "continue" as const };
+
+		const wrapped = `Use the subagent tool to delegate to the "${selectedAgent}" agent with this task:\n\n"${event.text}"\n\nSet agentScope to "both".`;
+		return { action: "transform" as const, text: wrapped, images: event.images };
+	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@draht/coding-agent",
-	"version": "2026.3.2",
+	"version": "2026.3.3",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"drahtConfig": {
@@ -8,6 +8,7 @@
 		"configDir": ".draht"
 	},
 	"bin": {
+		"coding-agent": "dist/cli.js",
 		"draht": "dist/cli.js",
 		"draht-tools": "bin/draht-tools.cjs"
 	},
@@ -30,6 +31,7 @@
 		"prompts",
 		"hooks",
 		"extensions",
+		"agents",
 		"bin",
 		"CHANGELOG.md"
 	],
@@ -38,16 +40,16 @@
 		"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/",
+		"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 dist/agents && shx cp -r prompts dist/prompts && shx cp -r hooks dist/hooks && shx cp -r extensions dist/extensions && shx cp -r agents dist/agents",
+		"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 -r agents 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": "workspace:*",
-		"@draht/ai": "workspace:*",
-		"@draht/tui": "workspace:*",
+		"@draht/agent-core": "2026.3.3",
+		"@draht/ai": "2026.3.3",
+		"@draht/tui": "2026.3.3",
 		"@silvia-odwyer/photon-node": "^0.3.4",
 		"chalk": "^5.5.0",
 		"cli-highlight": "^2.1.11",
@@ -96,7 +98,7 @@
 	},
 	"repository": {
 		"type": "git",
-		"url": "git+https://github.com/badlogic/pi-mono.git",
+		"url": "git+https://github.com/draht-dev/draht.git",
 		"directory": "packages/coding-agent"
 	},
 	"engines": {

package/prompts/commands/discuss-phase.md

@@ -8,12 +8,12 @@ Capture implementation decisions before planning a phase.
 ```
 
 ## Steps
-1. Run `draht phase-info N` to load phase context
+1. Run `draht-tools 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"`
+5. Record decisions with `draht-tools save-context N`
+6. Commit: `draht-tools commit-docs "capture phase N context"`
 
 ## Gray Area Categories
 - **Visual features** → Layout, density, interactions, empty states

package/prompts/commands/execute-phase.md

@@ -8,36 +8,36 @@ Execute all plans in a phase with atomic commits.
 ```
 
 ## Steps
-1. Run `draht discover-plans N` to find and order plans
+1. Run `draht-tools discover-plans N` to find and order plans
 2. For each plan in dependency order:
-   a. Load plan: `draht read-plan N P`
+   a. Load plan: `draht-tools read-plan N P`
    b. Execute each task in strict TDD cycle:
 
       **🔴 RED — Write failing tests first**
       - Write the test cases from `<test>`
       - Run tests — confirm they FAIL (if they pass, the test is wrong)
-      - Commit failing tests: `draht commit-task N P T "red: test description"`
+      - Commit failing tests: `draht-tools commit-task N P T "red: test description"`
 
       **🟢 GREEN — Minimal implementation**
       - Write the minimum code from `<action>` to make tests pass
       - Use domain language from `<context>` and `<domain>` for all names
       - Run tests — confirm they PASS
-      - Commit: `draht commit-task N P T "green: task name"`
+      - Commit: `draht-tools commit-task N P T "green: task name"`
 
       **🔵 REFACTOR — Clean up with safety net**
       - Apply improvements from `<refactor>` (if any)
       - Run tests after each change — must stay green
       - Verify domain language compliance (names match DOMAIN.md)
-      - Commit: `draht commit-task N P T "refactor: description"`
+      - Commit: `draht-tools commit-task N P T "refactor: description"`
 
       **✅ VERIFY**
       - Run the `<verify>` step
       - Confirm `<done>` criteria met
 
-   c. Write summary: `draht write-summary N P`
-3. Phase verification: `draht verify-phase N`
-4. Update state: `draht update-state`
-5. Final commit: `draht commit-docs "complete phase N execution"`
+   c. Write summary: `draht-tools write-summary N P`
+3. Phase verification: `draht-tools verify-phase N`
+4. Update state: `draht-tools update-state`
+5. Final commit: `draht-tools commit-docs "complete phase N execution"`
 
 ## TDD Rules
 - Never write implementation before a failing test exists

package/prompts/commands/map-codebase.md

@@ -8,7 +8,7 @@ Analyze existing codebase before planning.
 ```
 
 ## Steps
-1. Run `draht map-codebase [dir]`
+1. Run `draht-tools map-codebase [dir]`
 2. Tool generates: STACK.md, ARCHITECTURE.md, CONVENTIONS.md, CONCERNS.md
 3. Review output, supplement with your own analysis if needed
 4. Identify implicit bounded contexts from directory structure:
@@ -29,4 +29,4 @@ Analyze existing codebase before planning.
    - Existing coverage configuration and goals (if any)
    - Which layers have tests today (unit, integration, e2e)
    - Gaps and recommendations
-8. Commit: `draht commit-docs "map existing codebase"`
+8. Commit: `draht-tools commit-docs "map existing codebase"`

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/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/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`