@oh-my-pi/pi-coding-agent 1.341.0 → 2.1.1337

package/src/core/tools/renderers.ts

@@ -6,19 +6,20 @@
 
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
-import type { Theme } from "../../modes/interactive/theme/theme.js";
-import type { RenderResultOptions } from "../custom-tools/types.js";
-import type { AskToolDetails } from "./ask.js";
-import type { FindToolDetails } from "./find.js";
-import type { GrepToolDetails } from "./grep.js";
-import type { LsToolDetails } from "./ls.js";
-import { renderCall as renderLspCall, renderResult as renderLspResult } from "./lsp/render.js";
-import type { LspToolDetails } from "./lsp/types.js";
-import type { NotebookToolDetails } from "./notebook.js";
-import { renderCall as renderTaskCall, renderResult as renderTaskResult } from "./task/render.js";
-import type { TaskToolDetails } from "./task/types.js";
-import { renderWebFetchCall, renderWebFetchResult, type WebFetchToolDetails } from "./web-fetch.js";
-import { renderWebSearchCall, renderWebSearchResult, type WebSearchRenderDetails } from "./web-search/render.js";
+import type { Theme } from "../../modes/interactive/theme/theme";
+import type { RenderResultOptions } from "../custom-tools/types";
+import type { AskToolDetails } from "./ask";
+import type { FindToolDetails } from "./find";
+import type { GrepToolDetails } from "./grep";
+import type { LsToolDetails } from "./ls";
+import { renderCall as renderLspCall, renderResult as renderLspResult } from "./lsp/render";
+import type { LspToolDetails } from "./lsp/types";
+import type { NotebookToolDetails } from "./notebook";
+import type { OutputToolDetails } from "./output";
+import { renderCall as renderTaskCall, renderResult as renderTaskResult } from "./task/render";
+import type { TaskToolDetails } from "./task/types";
+import { renderWebFetchCall, renderWebFetchResult, type WebFetchToolDetails } from "./web-fetch";
+import { renderWebSearchCall, renderWebSearchResult, type WebSearchRenderDetails } from "./web-search/render";
 
 // Tree drawing characters
 const TREE_MID = "├─";
@@ -416,6 +417,83 @@ const lspRenderer: ToolRenderer<LspArgs, LspToolDetails> = {
 	renderResult: renderLspResult,
 };
 
+// ============================================================================
+// Output Renderer
+// ============================================================================
+
+interface OutputArgs {
+	ids: string[];
+	format?: "raw" | "json" | "stripped";
+}
+
+/** Format byte count for display */
+function formatBytes(bytes: number): string {
+	if (bytes < 1024) return `${bytes}B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}K`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)}M`;
+}
+
+const outputRenderer: ToolRenderer<OutputArgs, OutputToolDetails> = {
+	renderCall(args, theme) {
+		const ids = args.ids?.join(", ") ?? "?";
+		const label = theme.fg("toolTitle", theme.bold("output"));
+		const format = args.format && args.format !== "raw" ? theme.fg("muted", ` (${args.format})`) : "";
+		return new Text(`${label} ${theme.fg("dim", ids)}${format}`, 0, 0);
+	},
+
+	renderResult(result, { expanded }, theme) {
+		const details = result.details;
+
+		// Error case: some IDs not found
+		if (details?.notFound?.length) {
+			let text = `${theme.fg("error", ICON_ERROR)} Not found: ${details.notFound.join(", ")}`;
+			if (details.availableIds?.length) {
+				text += `\n${theme.fg("dim", "Available:")} ${details.availableIds.join(", ")}`;
+			} else {
+				text += `\n${theme.fg("dim", "No outputs available in current session")}`;
+			}
+			return new Text(text, 0, 0);
+		}
+
+		const outputs = details?.outputs ?? [];
+
+		// No session case
+		if (outputs.length === 0) {
+			const textContent = result.content?.find((c: any) => c.type === "text")?.text;
+			return new Text(
+				`${theme.fg("warning", ICON_WARNING)} ${theme.fg("muted", textContent || "No outputs")}`,
+				0,
+				0,
+			);
+		}
+
+		// Success: single output
+		if (outputs.length === 1) {
+			const o = outputs[0];
+			const summary = `read ${o.id}.out.md (${o.lineCount} lines, ${formatBytes(o.charCount)})`;
+			return new Text(`${theme.fg("success", ICON_SUCCESS)} ${theme.fg("dim", summary)}`, 0, 0);
+		}
+
+		// Success: multiple outputs (tree display)
+		const expandHint = expanded ? "" : theme.fg("dim", " (Ctrl+O to expand)");
+		let text = `${theme.fg("success", ICON_SUCCESS)} ${theme.fg("dim", `read ${outputs.length} outputs`)}${expandHint}`;
+
+		const maxOutputs = expanded ? outputs.length : Math.min(outputs.length, 5);
+		for (let i = 0; i < maxOutputs; i++) {
+			const o = outputs[i];
+			const isLast = i === maxOutputs - 1 && (expanded || outputs.length <= 5);
+			const branch = isLast ? TREE_END : TREE_MID;
+			text += `\n ${theme.fg("dim", branch)} ${theme.fg("accent", o.id)} ${theme.fg("dim", `(${o.lineCount} lines)`)}`;
+		}
+
+		if (!expanded && outputs.length > 5) {
+			text += `\n ${theme.fg("dim", TREE_END)} ${theme.fg("muted", `… ${outputs.length - 5} more outputs`)}`;
+		}
+
+		return new Text(text, 0, 0);
+	},
+};
+
 // ============================================================================
 // Task Renderer
 // ============================================================================
@@ -534,6 +612,7 @@ export const toolRenderers: Record<
 	notebook: notebookRenderer,
 	ls: lsRenderer,
 	lsp: lspRenderer,
+	output: outputRenderer,
 	task: taskRenderer,
 	web_fetch: webFetchRenderer,
 	web_search: webSearchRenderer,

package/src/core/tools/review.ts

@@ -0,0 +1,268 @@
+/**
+ * Review tools - report_finding and submit_review
+ *
+ * Used by the reviewer agent to report findings in a structured way.
+ * Both tools are hidden by default - only enabled when explicitly listed in agent's tools.
+ */
+
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Container, Spacer, Text } from "@oh-my-pi/pi-tui";
+import { Type } from "@sinclair/typebox";
+import type { Theme } from "../../modes/interactive/theme/theme";
+
+const PRIORITY_LABELS: Record<number, string> = {
+	0: "P0",
+	1: "P1",
+	2: "P2",
+	3: "P3",
+};
+
+const _PRIORITY_DESCRIPTIONS: Record<number, string> = {
+	0: "Drop everything to fix. Blocking release, operations, or major usage.",
+	1: "Urgent. Should be addressed in the next cycle.",
+	2: "Normal. To be fixed eventually.",
+	3: "Low. Nice to have.",
+};
+
+// report_finding schema
+const ReportFindingParams = Type.Object({
+	title: Type.String({
+		description: "≤80 chars, imperative, prefixed with [P0-P3]. E.g., '[P1] Un-padding slices along wrong dimension'",
+	}),
+	body: Type.String({
+		description: "Markdown explaining why this is a problem. One paragraph max.",
+	}),
+	priority: Type.Union([Type.Literal(0), Type.Literal(1), Type.Literal(2), Type.Literal(3)], {
+		description: "0=P0 (critical), 1=P1 (urgent), 2=P2 (normal), 3=P3 (low)",
+	}),
+	confidence: Type.Number({
+		minimum: 0,
+		maximum: 1,
+		description: "Confidence score 0.0-1.0",
+	}),
+	file_path: Type.String({ description: "Absolute path to the file" }),
+	line_start: Type.Number({ description: "Start line of the issue" }),
+	line_end: Type.Number({ description: "End line of the issue" }),
+});
+
+interface ReportFindingDetails {
+	title: string;
+	body: string;
+	priority: number;
+	confidence: number;
+	file_path: string;
+	line_start: number;
+	line_end: number;
+}
+
+export const reportFindingTool: AgentTool<typeof ReportFindingParams, ReportFindingDetails, Theme> = {
+	name: "report_finding",
+	label: "Report Finding",
+	description: "Report a code review finding. Use this for each issue found. Call submit_review when done.",
+	parameters: ReportFindingParams,
+	hidden: true,
+
+	async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+		const { title, body, priority, confidence, file_path, line_start, line_end } = params;
+		const location = `${file_path}:${line_start}${line_end !== line_start ? `-${line_end}` : ""}`;
+
+		return {
+			content: [
+				{
+					type: "text",
+					text: `Finding recorded: ${PRIORITY_LABELS[priority]} ${title}\nLocation: ${location}\nConfidence: ${(confidence * 100).toFixed(0)}%`,
+				},
+			],
+			details: { title, body, priority, confidence, file_path, line_start, line_end },
+		};
+	},
+
+	renderCall(args, theme): Component {
+		const priority = PRIORITY_LABELS[args.priority as number] ?? "P?";
+		const color = args.priority === 0 ? "error" : args.priority === 1 ? "warning" : "muted";
+		const titleText = String(args.title).replace(/^\[P\d\]\s*/, "");
+		return new Text(
+			`${theme.fg("toolTitle", theme.bold("report_finding "))}${theme.fg(color, `[${priority}]`)} ${theme.fg("dim", titleText)}`,
+			0,
+			0,
+		);
+	},
+
+	renderResult(result, _options, theme): Component {
+		const { details } = result;
+		if (!details) {
+			const text = result.content[0];
+			return new Text(text?.type === "text" ? text.text : "", 0, 0);
+		}
+
+		const priority = PRIORITY_LABELS[details.priority] ?? "P?";
+		const color = details.priority === 0 ? "error" : details.priority === 1 ? "warning" : "muted";
+		const location = `${details.file_path}:${details.line_start}${details.line_end !== details.line_start ? `-${details.line_end}` : ""}`;
+
+		return new Text(
+			`${theme.fg("success", "✓")} ${theme.fg(color, `[${priority}]`)} ${theme.fg("dim", location)}`,
+			0,
+			0,
+		);
+	},
+};
+
+// submit_review schema
+const SubmitReviewParams = Type.Object({
+	overall_correctness: Type.Union([Type.Literal("correct"), Type.Literal("incorrect")], {
+		description: "Whether the patch is correct (no bugs, tests won't break)",
+	}),
+	explanation: Type.String({
+		description: "1-3 sentence explanation justifying the verdict",
+	}),
+	confidence: Type.Number({
+		minimum: 0,
+		maximum: 1,
+		description: "Overall confidence score 0.0-1.0",
+	}),
+});
+
+interface SubmitReviewDetails {
+	overall_correctness: "correct" | "incorrect";
+	explanation: string;
+	confidence: number;
+}
+
+export const submitReviewTool: AgentTool<typeof SubmitReviewParams, SubmitReviewDetails, Theme> = {
+	name: "submit_review",
+	label: "Submit Review",
+	description: "Submit the final review verdict. Call this after all findings have been reported.",
+	parameters: SubmitReviewParams,
+	hidden: true,
+
+	async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+		const { overall_correctness, explanation, confidence } = params;
+
+		let summary = `## Review Summary\n\n`;
+		summary += `**Verdict:** ${overall_correctness === "correct" ? "✓ Patch is correct" : "✗ Patch is incorrect"}\n`;
+		summary += `**Confidence:** ${(confidence * 100).toFixed(0)}%\n\n`;
+		summary += explanation;
+
+		return {
+			content: [{ type: "text", text: summary }],
+			details: { overall_correctness, explanation, confidence },
+		};
+	},
+
+	renderCall(args, theme): Component {
+		const verdict = args.overall_correctness === "correct" ? "correct" : "incorrect";
+		const color = args.overall_correctness === "correct" ? "success" : "error";
+		return new Text(
+			`${theme.fg("toolTitle", theme.bold("submit_review "))}${theme.fg(color, verdict)} ${theme.fg("dim", `(${((args.confidence as number) * 100).toFixed(0)}%)`)}`,
+			0,
+			0,
+		);
+	},
+
+	renderResult(result, { expanded }, theme): Component {
+		const { details } = result;
+		if (!details) {
+			const text = result.content[0];
+			return new Text(text?.type === "text" ? text.text : "", 0, 0);
+		}
+
+		const container = new Container();
+		const verdictColor = details.overall_correctness === "correct" ? "success" : "error";
+		const verdictIcon = details.overall_correctness === "correct" ? "✓" : "✗";
+
+		container.addChild(
+			new Text(
+				`${theme.fg(verdictColor, verdictIcon)} Patch is ${theme.fg(verdictColor, details.overall_correctness)} ${theme.fg("dim", `(${(details.confidence * 100).toFixed(0)}% confidence)`)}`,
+				0,
+				0,
+			),
+		);
+
+		if (expanded) {
+			container.addChild(new Spacer(1));
+			container.addChild(new Text(theme.fg("dim", details.explanation), 0, 0));
+		}
+
+		return container;
+	},
+};
+
+export function createReportFindingTool(): AgentTool<typeof ReportFindingParams, ReportFindingDetails, Theme> {
+	return reportFindingTool;
+}
+
+export function createSubmitReviewTool(): AgentTool<typeof SubmitReviewParams, SubmitReviewDetails, Theme> {
+	return submitReviewTool;
+}
+
+// Re-export types for external use
+export type { ReportFindingDetails, SubmitReviewDetails };
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Subprocess tool handlers - registered for extraction/rendering in task tool
+// ─────────────────────────────────────────────────────────────────────────────
+
+import path from "node:path";
+import { subprocessToolRegistry } from "./task/subprocess-tool-registry";
+
+// Register report_finding handler
+subprocessToolRegistry.register<ReportFindingDetails>("report_finding", {
+	extractData: (event) => event.result?.details as ReportFindingDetails | undefined,
+
+	renderInline: (data, theme) => {
+		const priority = PRIORITY_LABELS[data.priority] ?? "P?";
+		const color = data.priority === 0 ? "error" : data.priority === 1 ? "warning" : "muted";
+		const titleText = data.title.replace(/^\[P\d\]\s*/, "");
+		const loc = `${path.basename(data.file_path)}:${data.line_start}`;
+		return new Text(`${theme.fg(color, `[${priority}]`)} ${titleText} ${theme.fg("dim", loc)}`, 0, 0);
+	},
+
+	renderFinal: (allData, theme, expanded) => {
+		const container = new Container();
+		const displayCount = expanded ? allData.length : Math.min(3, allData.length);
+
+		for (let i = 0; i < displayCount; i++) {
+			const data = allData[i];
+			const priority = PRIORITY_LABELS[data.priority] ?? "P?";
+			const color = data.priority === 0 ? "error" : data.priority === 1 ? "warning" : "muted";
+			const titleText = data.title.replace(/^\[P\d\]\s*/, "");
+			const loc = `${path.basename(data.file_path)}:${data.line_start}`;
+
+			container.addChild(
+				new Text(`  ${theme.fg(color, `[${priority}]`)} ${titleText} ${theme.fg("dim", loc)}`, 0, 0),
+			);
+
+			if (expanded && data.body) {
+				container.addChild(new Text(`    ${theme.fg("dim", data.body)}`, 0, 0));
+			}
+		}
+
+		if (allData.length > displayCount) {
+			container.addChild(new Text(theme.fg("dim", `  ... ${allData.length - displayCount} more findings`), 0, 0));
+		}
+
+		return container;
+	},
+});
+
+// Register submit_review handler
+subprocessToolRegistry.register<SubmitReviewDetails>("submit_review", {
+	extractData: (event) => event.result?.details as SubmitReviewDetails | undefined,
+
+	// Terminate subprocess after review is submitted
+	shouldTerminate: () => true,
+
+	renderInline: (data, theme) => {
+		const verdictColor = data.overall_correctness === "correct" ? "success" : "error";
+		const verdictIcon = data.overall_correctness === "correct" ? "✓" : "✗";
+		return new Text(
+			`${theme.fg(verdictColor, verdictIcon)} Review: ${theme.fg(verdictColor, data.overall_correctness)} (${(data.confidence * 100).toFixed(0)}%)`,
+			0,
+			0,
+		);
+	},
+
+	// Note: renderFinal is NOT used for submit_review - we use the combined
+	// renderReviewResult in render.ts to show verdict + findings together
+});

package/src/core/tools/task/agents.ts

@@ -1,17 +1,24 @@
 /**
  * Bundled agent definitions.
  *
- * Agents are loaded from .md files in the bundled-agents directory.
- * These serve as defaults when no user/project agents are discovered.
+ * Agents are embedded at build time via Bun's import with { type: "text" }.
  */
 
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import type { AgentDefinition, AgentSource } from "./types.js";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const BUNDLED_AGENTS_DIR = path.join(__dirname, "bundled-agents");
+// Embed agent markdown files at build time
+import browserMd from "./bundled-agents/browser.md" with { type: "text" };
+import exploreMd from "./bundled-agents/explore.md" with { type: "text" };
+import planMd from "./bundled-agents/plan.md" with { type: "text" };
+import reviewerMd from "./bundled-agents/reviewer.md" with { type: "text" };
+import taskMd from "./bundled-agents/task.md" with { type: "text" };
+import type { AgentDefinition, AgentSource } from "./types";
+
+const EMBEDDED_AGENTS: { name: string; content: string }[] = [
+	{ name: "browser.md", content: browserMd },
+	{ name: "explore.md", content: exploreMd },
+	{ name: "plan.md", content: planMd },
+	{ name: "reviewer.md", content: reviewerMd },
+	{ name: "task.md", content: taskMd },
+];
 
 /**
  * Parse YAML frontmatter from markdown content.
@@ -47,16 +54,9 @@ function parseFrontmatter(content: string): { frontmatter: Record<string, string
 }
 
 /**
- * Load a single agent from a markdown file.
+ * Parse an agent from embedded content.
  */
-function loadAgentFromFile(filePath: string, source: AgentSource): AgentDefinition | null {
-	let content: string;
-	try {
-		content = fs.readFileSync(filePath, "utf-8");
-	} catch {
-		return null;
-	}
-
+function parseAgent(fileName: string, content: string, source: AgentSource): AgentDefinition | null {
 	const { frontmatter, body } = parseFrontmatter(content);
 
 	if (!frontmatter.name || !frontmatter.description) {
@@ -79,7 +79,7 @@ function loadAgentFromFile(filePath: string, source: AgentSource): AgentDefiniti
 		recursive,
 		systemPrompt: body,
 		source,
-		filePath,
+		filePath: `embedded:${fileName}`,
 	};
 }
 
@@ -87,7 +87,7 @@ function loadAgentFromFile(filePath: string, source: AgentSource): AgentDefiniti
 let bundledAgentsCache: AgentDefinition[] | null = null;
 
 /**
- * Load all bundled agents from the bundled-agents directory.
+ * Load all bundled agents from embedded content.
  * Results are cached after first load.
  */
 export function loadBundledAgents(): AgentDefinition[] {
@@ -97,24 +97,8 @@ export function loadBundledAgents(): AgentDefinition[] {
 
 	const agents: AgentDefinition[] = [];
 
-	if (!fs.existsSync(BUNDLED_AGENTS_DIR)) {
-		bundledAgentsCache = agents;
-		return agents;
-	}
-
-	let entries: fs.Dirent[];
-	try {
-		entries = fs.readdirSync(BUNDLED_AGENTS_DIR, { withFileTypes: true });
-	} catch {
-		bundledAgentsCache = agents;
-		return agents;
-	}
-
-	for (const entry of entries) {
-		if (!entry.name.endsWith(".md")) continue;
-
-		const filePath = path.join(BUNDLED_AGENTS_DIR, entry.name);
-		const agent = loadAgentFromFile(filePath, "bundled");
+	for (const { name, content } of EMBEDDED_AGENTS) {
+		const agent = parseAgent(name, content, "bundled");
 		if (agent) {
 			agents.push(agent);
 		}

package/src/core/tools/task/bundled-agents/reviewer.md

@@ -1,59 +1,74 @@
 ---
 name: reviewer
-description: Expert code reviewer for PRs and implementation changes
-tools: read, grep, glob, ls, bash
+description: Code review specialist for quality and security analysis
+tools: read, grep, find, ls, bash, task, report_finding, submit_review
 model: pi/slow, gpt-5.2-codex, gpt-5.2, codex, gpt
 ---
 
-You are an expert code reviewer. Analyze code changes and provide thorough reviews.
+You are acting as a reviewer for a proposed code change made by another engineer.
 
-## For PR Reviews
+Bash is for read-only commands only: `git diff`, `git log`, `git show`, `gh pr diff`. Do NOT modify files or run builds.
 
-1. If no PR number provided, run `gh pr list` to show open PRs
-2. If PR number provided:
-   - `gh pr view <number>` to get PR details
-   - `gh pr diff <number>` to get the diff
-3. Analyze changes and provide review
+# Review Strategy
 
-## For Implementation Reviews
+1. Run `git diff` (or `gh pr diff <number>`) to see the changes
+2. Read the modified files for full context
+3. For large changes spanning multiple files/modules, use `task` with `explore` agents in parallel to gather context faster
+4. Analyze for bugs, security issues, and code quality problems
+5. Use `report_finding` for each issue found
+6. Use `submit_review` to provide final verdict
 
-When reviewing implementation output from another agent:
+# Parallelization
 
-1. Read the files that were changed
-2. Understand the context and requirements
-3. Analyze the implementation quality
+For reviews touching many files, spawn `explore` agents to research in parallel:
+- Each agent can investigate a different module or concern
+- Example: one explores test coverage, another checks related implementations
+- Gather their findings, then synthesize into your review
 
-## Review Focus
+# What to Flag
 
-- **Correctness**: Does the code do what it's supposed to?
-- **Project Conventions**: Does it follow existing patterns?
-- **Performance**: Any performance implications?
-- **Test Coverage**: Are changes adequately tested?
-- **Security**: Any security considerations?
-- **Edge Cases**: Are edge cases handled?
+Only flag issues where ALL of these apply:
 
-## Output Format
+1. It meaningfully impacts the accuracy, performance, security, or maintainability of the code
+2. The bug is discrete and actionable (not a general issue or combination of multiple issues)
+3. Fixing it doesn't demand rigor not present elsewhere in the codebase
+4. The bug was introduced in this commit (don't flag pre-existing bugs)
+5. The author would likely fix the issue if made aware of it
+6. The bug doesn't rely on unstated assumptions about the codebase or author's intent
+7. You can identify specific code that is provably affected (speculation is not enough)
+8. The issue is clearly not an intentional change by the author
 
-### Overview
+# Priority Levels
 
-What the changes do.
+- **P0**: Drop everything to fix. Blocking release, operations, or major usage. Only use for universal issues that do not depend on assumptions about inputs.
+- **P1**: Urgent. Should be addressed in the next cycle.
+- **P2**: Normal. To be fixed eventually.
+- **P3**: Low. Nice to have.
 
-### Strengths
+# Comment Guidelines
 
-What's done well.
+1. Be clear about WHY the issue is a bug
+2. Communicate severity appropriately - don't overstate
+3. Keep body to one paragraph max
+4. Code snippets should be ≤3 lines, wrapped in markdown code tags
+5. Clearly state what conditions are necessary for the bug to arise
+6. Tone: matter-of-fact, not accusatory or overly positive
+7. Write so the author can immediately grasp the idea without close reading
+8. Avoid flattery and phrases like "Great job...", "Thanks for..."
 
-### Issues
+# CRITICAL
 
-Problems that should be fixed (with file:line references).
+You MUST call `submit_review` before ending your response, even if you found no issues.
+The review is only considered complete when `submit_review` is called.
+Failure to call `submit_review` means the review was not submitted.
 
-### Suggestions
+# Output
 
-Improvements to consider (optional, not blocking).
+- Use `report_finding` for each issue. Continue until you've listed every qualifying finding.
+- If there is no finding that a person would definitely want to fix, prefer outputting no findings.
+- Ignore trivial style unless it obscures meaning or violates documented standards.
+- Use `submit_review` at the end with your overall verdict:
+  - **correct**: Existing code and tests will not break, patch is free of bugs and blocking issues
+  - **incorrect**: Has bugs or blocking issues that must be addressed
 
-### Verdict
-
-- ✅ **Approve**: Ready to merge/complete
-- 🔄 **Request Changes**: Issues must be addressed
-- 💬 **Comment**: Minor suggestions, can proceed
-
-Keep reviews concise but thorough. Focus on substance over style nitpicks.
+Ignore non-blocking issues (style, formatting, typos, documentation, nits) when determining correctness.

package/src/core/tools/task/commands.ts

@@ -1,17 +1,23 @@
 /**
  * Workflow commands for orchestrating multi-agent workflows.
  *
- * Commands are loaded from .md files with YAML frontmatter.
- * They define multi-step workflows that chain agent outputs.
+ * Commands are embedded at build time via Bun's import with { type: "text" }.
  */
 
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { fileURLToPath } from "node:url";
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const BUNDLED_COMMANDS_DIR = path.join(__dirname, "bundled-commands");
+// Embed command markdown files at build time
+import architectPlanMd from "./bundled-commands/architect-plan.md" with { type: "text" };
+import implementMd from "./bundled-commands/implement.md" with { type: "text" };
+import implementWithCriticMd from "./bundled-commands/implement-with-critic.md" with { type: "text" };
+
+const EMBEDDED_COMMANDS: { name: string; content: string }[] = [
+	{ name: "architect-plan.md", content: architectPlanMd },
+	{ name: "implement-with-critic.md", content: implementWithCriticMd },
+	{ name: "implement.md", content: implementMd },
+];
 
 /** Workflow command definition */
 export interface WorkflowCommand {
@@ -56,9 +62,9 @@ function parseFrontmatter(content: string): { frontmatter: Record<string, string
 }
 
 /**
- * Load commands from a directory.
+ * Load commands from a directory (for user/project commands).
  */
-function loadCommandsFromDir(dir: string, source: "bundled" | "user" | "project"): WorkflowCommand[] {
+function loadCommandsFromDir(dir: string, source: "user" | "project"): WorkflowCommand[] {
 	const commands: WorkflowCommand[] = [];
 
 	if (!fs.existsSync(dir)) {
@@ -137,15 +143,30 @@ function findNearestDir(cwd: string, relPath: string): string | null {
 let bundledCommandsCache: WorkflowCommand[] | null = null;
 
 /**
- * Load all bundled commands.
+ * Load all bundled commands from embedded content.
  */
 export function loadBundledCommands(): WorkflowCommand[] {
 	if (bundledCommandsCache !== null) {
 		return bundledCommandsCache;
 	}
 
-	bundledCommandsCache = loadCommandsFromDir(BUNDLED_COMMANDS_DIR, "bundled");
-	return bundledCommandsCache;
+	const commands: WorkflowCommand[] = [];
+
+	for (const { name, content } of EMBEDDED_COMMANDS) {
+		const { frontmatter, body } = parseFrontmatter(content);
+		const cmdName = name.replace(/\.md$/, "");
+
+		commands.push({
+			name: cmdName,
+			description: frontmatter.description || "",
+			instructions: body,
+			source: "bundled",
+			filePath: `embedded:${name}`,
+		});
+	}
+
+	bundledCommandsCache = commands;
+	return commands;
 }
 
 /**