@oh-my-pi/pi-coding-agent 8.1.0 → 8.2.0

package/src/ssh/connection-manager.ts

@@ -1,9 +1,9 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { CONFIG_DIR_NAME } from "@oh-my-pi/pi-coding-agent/config";
-import { logger } from "@oh-my-pi/pi-utils";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { isEnoent, logger } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
+import { CONFIG_DIR_NAME } from "../config";
 
 export interface SSHConnectionTarget {
 	name: string;
@@ -25,52 +25,44 @@ export interface SSHHostInfo {
 	compatEnabled: boolean;
 }
 
-const CONTROL_DIR = join(homedir(), CONFIG_DIR_NAME, "ssh-control");
-const CONTROL_PATH = join(CONTROL_DIR, "%h.sock");
-const HOST_INFO_DIR = join(homedir(), CONFIG_DIR_NAME, "remote-host");
+const CONTROL_DIR = path.join(os.homedir(), CONFIG_DIR_NAME, "ssh-control");
+const CONTROL_PATH = path.join(CONTROL_DIR, "%h.sock");
+const HOST_INFO_DIR = path.join(os.homedir(), CONFIG_DIR_NAME, "remote-host");
 const HOST_INFO_VERSION = 2;
 
 const activeHosts = new Map<string, SSHConnectionTarget>();
 const pendingConnections = new Map<string, Promise<void>>();
 const hostInfoCache = new Map<string, SSHHostInfo>();
 
-function ensureControlDir(): void {
-	if (!existsSync(CONTROL_DIR)) {
-		mkdirSync(CONTROL_DIR, { recursive: true, mode: 0o700 });
-	}
+async function ensureControlDir(): Promise<void> {
+	await fs.mkdir(CONTROL_DIR, { recursive: true, mode: 0o700 });
 	try {
-		chmodSync(CONTROL_DIR, 0o700);
+		await fs.chmod(CONTROL_DIR, 0o700);
 	} catch (err) {
 		logger.debug("SSH control dir chmod failed", { path: CONTROL_DIR, error: String(err) });
 	}
 }
 
-function ensureHostInfoDir(): void {
-	if (!existsSync(HOST_INFO_DIR)) {
-		mkdirSync(HOST_INFO_DIR, { recursive: true, mode: 0o700 });
-	}
-	try {
-		chmodSync(HOST_INFO_DIR, 0o700);
-	} catch (err) {
-		logger.debug("SSH host info dir chmod failed", { path: HOST_INFO_DIR, error: String(err) });
-	}
-}
-
 function sanitizeHostName(name: string): string {
 	const sanitized = name.replace(/[^a-zA-Z0-9._-]+/g, "_");
 	return sanitized.length > 0 ? sanitized : "host";
 }
 
 function getHostInfoPath(name: string): string {
-	return join(HOST_INFO_DIR, `${sanitizeHostName(name)}.json`);
+	return path.join(HOST_INFO_DIR, `${sanitizeHostName(name)}.json`);
 }
 
-function validateKeyPermissions(keyPath?: string): void {
+async function validateKeyPermissions(keyPath?: string): Promise<void> {
 	if (!keyPath) return;
-	if (!existsSync(keyPath)) {
-		throw new Error(`SSH key not found: ${keyPath}`);
+	let stats: Awaited<ReturnType<typeof fs.stat>>;
+	try {
+		stats = await fs.stat(keyPath);
+	} catch (err) {
+		if (isEnoent(err)) {
+			throw new Error(`SSH key not found: ${keyPath}`);
+		}
+		throw err;
 	}
-	const stats = statSync(keyPath);
 	if (!stats.isFile()) {
 		throw new Error(`SSH key is not a file: ${keyPath}`);
 	}
@@ -208,31 +200,31 @@ function shouldRefreshHostInfo(host: SSHConnectionTarget, info: SSHHostInfo): bo
 	return false;
 }
 
-function loadHostInfoFromDisk(host: SSHConnectionTarget): SSHHostInfo | undefined {
+async function loadHostInfoFromDisk(host: SSHConnectionTarget): Promise<SSHHostInfo | undefined> {
 	const path = getHostInfoPath(host.name);
-	if (!existsSync(path)) return undefined;
 	try {
-		const raw = readFileSync(path, "utf-8");
+		const raw = await fs.readFile(path, "utf-8");
 		const parsed = parseHostInfo(JSON.parse(raw));
 		if (!parsed) return undefined;
 		const resolved = applyCompatOverride(host, parsed);
 		hostInfoCache.set(host.name, resolved);
 		return resolved;
 	} catch (err) {
+		if (isEnoent(err)) return undefined;
 		logger.warn("Failed to load SSH host info", { host: host.name, error: String(err) });
 		return undefined;
 	}
 }
 
-function loadHostInfoFromDiskByName(hostName: string): SSHHostInfo | undefined {
+async function loadHostInfoFromDiskByName(hostName: string): Promise<SSHHostInfo | undefined> {
 	const path = getHostInfoPath(hostName);
-	if (!existsSync(path)) return undefined;
 	try {
-		const raw = readFileSync(path, "utf-8");
+		const raw = await fs.readFile(path, "utf-8");
 		const parsed = parseHostInfo(JSON.parse(raw));
 		if (!parsed) return undefined;
 		return parsed;
 	} catch (err) {
+		if (isEnoent(err)) return undefined;
 		logger.warn("Failed to load SSH host info", { host: hostName, error: String(err) });
 		return undefined;
 	}
@@ -240,7 +232,6 @@ function loadHostInfoFromDiskByName(hostName: string): SSHHostInfo | undefined {
 
 async function persistHostInfo(host: SSHConnectionTarget, info: SSHHostInfo): Promise<void> {
 	try {
-		ensureHostInfoDir();
 		const path = getHostInfoPath(host.name);
 		const payload = { ...info, version: HOST_INFO_VERSION };
 		hostInfoCache.set(host.name, payload);
@@ -252,7 +243,7 @@ async function persistHostInfo(host: SSHConnectionTarget, info: SSHHostInfo): Pr
 
 async function probeHostInfo(host: SSHConnectionTarget): Promise<SSHHostInfo> {
 	const command = 'echo "$OSTYPE|$SHELL|$BASH_VERSION" 2>/dev/null || echo "%OS%|%COMSPEC%|"';
-	const result = await runSshCaptureSync(buildRemoteCommand(host, command));
+	const result = await runSshCaptureSync(await buildRemoteCommand(host, command));
 	if (result.exitCode !== 0 && !result.stdout) {
 		logger.debug("SSH host probe failed", { host: host.name, error: result.stderr });
 		const fallback: SSHHostInfo = {
@@ -315,11 +306,11 @@ async function probeHostInfo(host: SSHConnectionTarget): Promise<SSHHostInfo> {
 	const hasBash = !unexpandedPosixVars && (Boolean(bashVersion) || shell === "bash");
 	let compatShell: SSHHostInfo["compatShell"];
 	if (os === "windows" && host.compat !== false) {
-		const bashProbe = await runSshCaptureSync(buildRemoteCommand(host, 'bash -lc "echo OMP_BASH_OK"'));
+		const bashProbe = await runSshCaptureSync(await buildRemoteCommand(host, 'bash -lc "echo OMP_BASH_OK"'));
 		if (bashProbe.exitCode === 0 && bashProbe.stdout.includes("OMP_BASH_OK")) {
 			compatShell = "bash";
 		} else {
-			const shProbe = await runSshCaptureSync(buildRemoteCommand(host, 'sh -lc "echo OMP_SH_OK"'));
+			const shProbe = await runSshCaptureSync(await buildRemoteCommand(host, 'sh -lc "echo OMP_SH_OK"'));
 			if (shProbe.exitCode === 0 && shProbe.stdout.includes("OMP_SH_OK")) {
 				compatShell = "sh";
 			}
@@ -344,18 +335,20 @@ async function probeHostInfo(host: SSHConnectionTarget): Promise<SSHHostInfo> {
 	return info;
 }
 
-export function getHostInfo(hostName: string): SSHHostInfo | undefined {
-	return hostInfoCache.get(hostName) ?? loadHostInfoFromDiskByName(hostName);
+export async function getHostInfo(hostName: string): Promise<SSHHostInfo | undefined> {
+	const cached = hostInfoCache.get(hostName);
+	if (cached) return cached;
+	return loadHostInfoFromDiskByName(hostName);
 }
 
-export function getHostInfoForHost(host: SSHConnectionTarget): SSHHostInfo | undefined {
+export async function getHostInfoForHost(host: SSHConnectionTarget): Promise<SSHHostInfo | undefined> {
 	const cached = hostInfoCache.get(host.name);
 	if (cached) {
 		const resolved = applyCompatOverride(host, cached);
 		if (resolved !== cached) hostInfoCache.set(host.name, resolved);
 		return resolved;
 	}
-	return loadHostInfoFromDisk(host);
+	return await loadHostInfoFromDisk(host);
 }
 
 export async function ensureHostInfo(host: SSHConnectionTarget): Promise<SSHHostInfo> {
@@ -365,7 +358,7 @@ export async function ensureHostInfo(host: SSHConnectionTarget): Promise<SSHHost
 		hostInfoCache.set(host.name, resolved);
 		if (!shouldRefreshHostInfo(host, resolved)) return resolved;
 	}
-	const fromDisk = loadHostInfoFromDisk(host);
+	const fromDisk = await loadHostInfoFromDisk(host);
 	if (fromDisk && !shouldRefreshHostInfo(host, fromDisk)) return fromDisk;
 	await ensureConnection(host);
 	const current = hostInfoCache.get(host.name);
@@ -373,8 +366,8 @@ export async function ensureHostInfo(host: SSHConnectionTarget): Promise<SSHHost
 	return probeHostInfo(host);
 }
 
-export function buildRemoteCommand(host: SSHConnectionTarget, command: string): string[] {
-	validateKeyPermissions(host.keyPath);
+export async function buildRemoteCommand(host: SSHConnectionTarget, command: string): Promise<string[]> {
+	await validateKeyPermissions(host.keyPath);
 	return [...buildCommonArgs(host), buildSshTarget(host), command];
 }
 
@@ -388,14 +381,14 @@ export async function ensureConnection(host: SSHConnectionTarget): Promise<void>
 
 	const promise = (async () => {
 		ensureSshBinary();
-		ensureControlDir();
-		validateKeyPermissions(host.keyPath);
+		await ensureControlDir();
+		await validateKeyPermissions(host.keyPath);
 
 		const target = buildSshTarget(host);
 		const check = await runSshSync(["-O", "check", ...buildCommonArgs(host), target]);
 		if (check.exitCode === 0) {
 			activeHosts.set(key, host);
-			if (!hostInfoCache.has(key) && !loadHostInfoFromDisk(host)) {
+			if (!hostInfoCache.has(key) && !(await loadHostInfoFromDisk(host))) {
 				await probeHostInfo(host);
 			}
 			return;
@@ -408,7 +401,7 @@ export async function ensureConnection(host: SSHConnectionTarget): Promise<void>
 		}
 
 		activeHosts.set(key, host);
-		if (!hostInfoCache.has(key) && !loadHostInfoFromDisk(host)) {
+		if (!hostInfoCache.has(key) && !(await loadHostInfoFromDisk(host))) {
 			await probeHostInfo(host);
 		}
 	})();

package/src/ssh/ssh-executor.ts

@@ -1,5 +1,5 @@
-import { OutputSink } from "@oh-my-pi/pi-coding-agent/session/streaming-output";
 import { cspawn, logger, ptree } from "@oh-my-pi/pi-utils";
+import { OutputSink } from "../session/streaming-output";
 import { buildRemoteCommand, ensureConnection, ensureHostInfo, type SSHConnectionTarget } from "./connection-manager";
 import { hasSshfs, mountRemote } from "./sshfs-mount";
 
@@ -76,7 +76,7 @@ export async function executeSSH(
 		}
 	}
 
-	const child = cspawn(["ssh", ...buildRemoteCommand(host, resolvedCommand)], {
+	const child = cspawn(["ssh", ...(await buildRemoteCommand(host, resolvedCommand))], {
 		signal: options?.signal,
 		timeout: options?.timeout,
 	});

package/src/ssh/sshfs-mount.ts

@@ -1,25 +1,21 @@
-import { chmodSync, existsSync, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { CONFIG_DIR_NAME } from "@oh-my-pi/pi-coding-agent/config";
-import { logger } from "@oh-my-pi/pi-utils";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
 import { $ } from "bun";
+import { CONFIG_DIR_NAME } from "../config";
 import { getControlDir, getControlPathTemplate, type SSHConnectionTarget } from "./connection-manager";
 
-const REMOTE_DIR = join(homedir(), CONFIG_DIR_NAME, "remote");
+const REMOTE_DIR = path.join(os.homedir(), CONFIG_DIR_NAME, "remote");
 const CONTROL_DIR = getControlDir();
 const CONTROL_PATH = getControlPathTemplate();
 
 const mountedPaths = new Set<string>();
 
-function ensureDir(path: string, mode = 0o700): void {
-	if (!existsSync(path)) {
-		mkdirSync(path, { recursive: true, mode });
-	}
+async function ensureDir(path: string, mode = 0o700): Promise<void> {
 	try {
-		chmodSync(path, mode);
-	} catch (err) {
-		logger.debug("SSHFS dir chmod failed", { path, error: String(err) });
+		await fs.promises.mkdir(path, { recursive: true, mode });
+	} catch {
+		await fs.promises.chmod(path, mode).catch(e => void e);
 	}
 }
 
@@ -30,7 +26,7 @@ function getMountName(host: SSHConnectionTarget): string {
 }
 
 function getMountPath(host: SSHConnectionTarget): string {
-	return join(REMOTE_DIR, getMountName(host));
+	return path.join(REMOTE_DIR, getMountName(host));
 }
 
 function buildSshTarget(host: SSHConnectionTarget): string {
@@ -95,11 +91,8 @@ export async function isMounted(path: string): Promise<boolean> {
 export async function mountRemote(host: SSHConnectionTarget, remotePath = "/"): Promise<string | undefined> {
 	if (!hasSshfs()) return undefined;
 
-	ensureDir(REMOTE_DIR);
-	ensureDir(CONTROL_DIR);
-
 	const mountPath = getMountPath(host);
-	ensureDir(mountPath);
+	await Promise.all([ensureDir(REMOTE_DIR), ensureDir(CONTROL_DIR), ensureDir(mountPath)]);
 
 	if (await isMounted(mountPath)) {
 		mountedPaths.add(mountPath);

package/src/system-prompt.ts

@@ -1,26 +1,18 @@
 /**
  * System prompt construction and project context loading
  */
-
-import { existsSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { contextFileCapability } from "@oh-my-pi/pi-coding-agent/capability/context-file";
-import { systemPromptCapability } from "@oh-my-pi/pi-coding-agent/capability/system-prompt";
-import { renderPromptTemplate } from "@oh-my-pi/pi-coding-agent/config/prompt-templates";
-import type { SkillsSettings } from "@oh-my-pi/pi-coding-agent/config/settings-manager";
-import {
-	type ContextFile,
-	loadCapability,
-	type SystemPrompt as SystemPromptFile,
-} from "@oh-my-pi/pi-coding-agent/discovery";
-import { loadSkills, type Skill } from "@oh-my-pi/pi-coding-agent/extensibility/skills";
-import customSystemPromptTemplate from "@oh-my-pi/pi-coding-agent/prompts/system/custom-system-prompt.md" with {
-	type: "text",
-};
-import systemPromptTemplate from "@oh-my-pi/pi-coding-agent/prompts/system/system-prompt.md" with { type: "text" };
+import * as os from "node:os";
+import * as path from "node:path";
 import { $ } from "bun";
 import chalk from "chalk";
+import { contextFileCapability } from "./capability/context-file";
+import { systemPromptCapability } from "./capability/system-prompt";
+import { renderPromptTemplate } from "./config/prompt-templates";
+import type { SkillsSettings } from "./config/settings-manager";
+import { type ContextFile, loadCapability, type SystemPrompt as SystemPromptFile } from "./discovery";
+import { loadSkills, type Skill } from "./extensibility/skills";
+import customSystemPromptTemplate from "./prompts/system/custom-system-prompt.md" with { type: "text" };
+import systemPromptTemplate from "./prompts/system/system-prompt.md" with { type: "text" };
 import type { ToolName } from "./tools";
 
 interface GitContext {
@@ -42,7 +34,7 @@ export async function loadGitContext(cwd: string): Promise<GitContext | null> {
 			.quiet()
 			.text()
 			.catch(() => null)
-			.then((text) => text?.trim() ?? null);
+			.then(text => text?.trim() ?? null);
 
 	// Check if inside a git repo
 	const isGitRepo = await git("rev-parse", "--is-inside-work-tree");
@@ -86,7 +78,7 @@ function firstNonEmptyLine(value: string | null): string | null {
 	if (!value) return null;
 	const line = value
 		.split("\n")
-		.map((entry) => entry.trim())
+		.map(entry => entry.trim())
 		.filter(Boolean)[0];
 	return line ?? null;
 }
@@ -94,9 +86,9 @@ function firstNonEmptyLine(value: string | null): string | null {
 function parseWmicTable(output: string, header: string): string | null {
 	const lines = output
 		.split("\n")
-		.map((line) => line.trim())
+		.map(line => line.trim())
 		.filter(Boolean);
-	const filtered = lines.filter((line) => line.toLowerCase() !== header.toLowerCase());
+	const filtered = lines.filter(line => line.toLowerCase() !== header.toLowerCase());
 	return filtered[0] ?? null;
 }
 
@@ -137,8 +129,8 @@ function listAgentsMdFiles(root: string, limit: number): string[] {
 			new Bun.Glob(AGENTS_MD_PATTERN).scanSync({ cwd: root, onlyFiles: true, dot: false, absolute: false }),
 		);
 		const normalized = entries
-			.map((entry) => normalizePath(entry))
-			.filter((entry) => entry.length > 0 && !entry.includes("node_modules"))
+			.map(entry => normalizePath(entry))
+			.filter(entry => entry.length > 0 && !entry.includes("node_modules"))
 			.sort();
 		return normalized.length > limit ? normalized.slice(0, limit) : normalized;
 	} catch {
@@ -274,8 +266,8 @@ async function getCpuModel(): Promise<string | null> {
 			if (lscpu) {
 				const match = lscpu
 					.split("\n")
-					.map((line) => line.trim())
-					.find((line) => line.toLowerCase().startsWith("model name:"));
+					.map(line => line.trim())
+					.find(line => line.toLowerCase().startsWith("model name:"));
 				if (match) return match.split(":").slice(1).join(":").trim();
 			}
 			const cpuInfo = await Bun.file("/proc/cpuinfo")
@@ -370,7 +362,7 @@ function normalizeDesktopValue(value: string): string {
 	if (!trimmed) return "unknown";
 	const parts = trimmed
 		.split(":")
-		.map((part) => part.trim())
+		.map(part => part.trim())
 		.filter(Boolean);
 	return parts[0] ?? trimmed;
 }
@@ -436,14 +428,15 @@ interface SystemInfoCache {
 }
 
 function getSystemInfoCachePath(): string {
-	return join(homedir(), ".omp", "system_info.json");
+	return path.join(os.homedir(), ".omp", "system_info.json");
 }
 
 async function loadSystemInfoCache(): Promise<SystemInfoCache | null> {
 	try {
 		const cachePath = getSystemInfoCachePath();
-		if (!existsSync(cachePath)) return null;
-		const content = await Bun.file(cachePath).json();
+		const file = Bun.file(cachePath);
+		if (!(await file.exists())) return null;
+		const content = await file.json();
 		return content as SystemInfoCache;
 	} catch {
 		return null;
@@ -494,7 +487,7 @@ async function getDiskInfo(): Promise<string | null> {
 				.text()
 				.catch(() => null);
 			if (!output) return null;
-			const lines = output.split("\n").filter((l) => l.trim() && !l.startsWith("Node"));
+			const lines = output.split("\n").filter(l => l.trim() && !l.startsWith("Node"));
 			const disks: string[] = [];
 			for (const line of lines) {
 				const parts = line.split(",");
@@ -590,7 +583,7 @@ export async function loadProjectContextFiles(
 	const result = await loadCapability(contextFileCapability.id, { cwd: resolvedCwd });
 
 	// Convert ContextFile items and preserve depth info
-	const files = result.items.map((item) => {
+	const files = result.items.map(item => {
 		const contextFile = item as ContextFile;
 		return {
 			path: contextFile.path,
@@ -622,8 +615,8 @@ export async function loadSystemPromptFiles(options: LoadContextFilesOptions = {
 	if (result.items.length === 0) return null;
 
 	// Combine all SYSTEM.md contents (user-level first, then project-level)
-	const userLevel = result.items.filter((item) => item.level === "user");
-	const projectLevel = result.items.filter((item) => item.level === "project");
+	const userLevel = result.items.filter(item => item.level === "user");
+	const projectLevel = result.items.filter(item => item.level === "project");
 
 	const parts: string[] = [];
 	for (const item of [...userLevel, ...projectLevel]) {

package/src/task/agents.ts

@@ -3,16 +3,15 @@
  *
  * Agents are embedded at build time via Bun's import with { type: "text" }.
  */
-
-import { renderPromptTemplate } from "@oh-my-pi/pi-coding-agent/config/prompt-templates";
-import { parseAgentFields } from "@oh-my-pi/pi-coding-agent/discovery/helpers";
-import exploreMd from "@oh-my-pi/pi-coding-agent/prompts/agents/explore.md" with { type: "text" };
+import { renderPromptTemplate } from "../config/prompt-templates";
+import { parseAgentFields } from "../discovery/helpers";
+import exploreMd from "../prompts/agents/explore.md" with { type: "text" };
 // Embed agent markdown files at build time
-import agentFrontmatterTemplate from "@oh-my-pi/pi-coding-agent/prompts/agents/frontmatter.md" with { type: "text" };
-import planMd from "@oh-my-pi/pi-coding-agent/prompts/agents/plan.md" with { type: "text" };
-import reviewerMd from "@oh-my-pi/pi-coding-agent/prompts/agents/reviewer.md" with { type: "text" };
-import taskMd from "@oh-my-pi/pi-coding-agent/prompts/agents/task.md" with { type: "text" };
-import { parseFrontmatter } from "@oh-my-pi/pi-coding-agent/utils/frontmatter";
+import agentFrontmatterTemplate from "../prompts/agents/frontmatter.md" with { type: "text" };
+import planMd from "../prompts/agents/plan.md" with { type: "text" };
+import reviewerMd from "../prompts/agents/reviewer.md" with { type: "text" };
+import taskMd from "../prompts/agents/task.md" with { type: "text" };
+import { parseFrontmatter } from "../utils/frontmatter";
 import type { AgentDefinition, AgentSource } from "./types";
 
 interface AgentFrontmatter {
@@ -69,30 +68,56 @@ const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 	},
 ];
 
-const EMBEDDED_AGENTS: { name: string; content: string }[] = EMBEDDED_AGENT_DEFS.map((def) => ({
+const EMBEDDED_AGENTS: { name: string; content: string }[] = EMBEDDED_AGENT_DEFS.map(def => ({
 	name: def.fileName,
 	content: buildAgentContent(def),
 }));
 
+export class AgentParsingError extends Error {
+	constructor(
+		error: Error,
+		public readonly source?: unknown,
+	) {
+		super(`Failed to parse agent: ${error.message}`, { cause: error });
+		this.name = "AgentParsingError";
+	}
+
+	toString(): string {
+		const details: string[] = [this.message];
+		if (this.source !== undefined) {
+			details.push(`Source: ${JSON.stringify(this.source)}`);
+		}
+		if (this.cause && typeof this.cause === "object" && "stack" in this.cause && this.cause.stack) {
+			details.push(`Stack:\n${this.cause.stack}`);
+		} else if (this.stack) {
+			details.push(`Stack:\n${this.stack}`);
+		}
+		return details.join("\n\n");
+	}
+}
+
 /**
  * Parse an agent from embedded content.
  */
-function parseAgent(fileName: string, content: string, source: AgentSource): AgentDefinition | null {
+export function parseAgent(
+	filePath: string,
+	content: string,
+	source: AgentSource,
+	level: "fatal" | "warn" | "off" = "fatal",
+): AgentDefinition {
 	const { frontmatter, body } = parseFrontmatter(content, {
-		source: `embedded:${fileName}`,
-		level: "fatal",
+		location: filePath,
+		level,
 	});
 	const fields = parseAgentFields(frontmatter);
-
 	if (!fields) {
-		return null;
+		throw new AgentParsingError(new Error("Invalid agent fields"), filePath);
 	}
-
 	return {
 		...fields,
 		systemPrompt: body,
 		source,
-		filePath: `embedded:${fileName}`,
+		filePath,
 	};
 }
 
@@ -107,25 +132,15 @@ export function loadBundledAgents(): AgentDefinition[] {
 	if (bundledAgentsCache !== null) {
 		return bundledAgentsCache;
 	}
-
-	const agents: AgentDefinition[] = [];
-
-	for (const { name, content } of EMBEDDED_AGENTS) {
-		const agent = parseAgent(name, content, "bundled");
-		if (agent) {
-			agents.push(agent);
-		}
-	}
-
-	bundledAgentsCache = agents;
-	return agents;
+	bundledAgentsCache = EMBEDDED_AGENTS.map(({ name, content }) => parseAgent(`embedded:${name}`, content, "bundled"));
+	return bundledAgentsCache;
 }
 
 /**
  * Get a bundled agent by name.
  */
 export function getBundledAgent(name: string): AgentDefinition | undefined {
-	return loadBundledAgents().find((a) => a.name === name);
+	return loadBundledAgents().find(a => a.name === name);
 }
 
 /**

package/src/task/commands.ts

@@ -3,14 +3,13 @@
  *
  * Commands are embedded at build time via Bun's import with { type: "text" }.
  */
-
 import * as path from "node:path";
-import { type SlashCommand, slashCommandCapability } from "@oh-my-pi/pi-coding-agent/capability/slash-command";
-import { renderPromptTemplate } from "@oh-my-pi/pi-coding-agent/config/prompt-templates";
-import { loadCapability } from "@oh-my-pi/pi-coding-agent/discovery";
+import { type SlashCommand, slashCommandCapability } from "../capability/slash-command";
+import { renderPromptTemplate } from "../config/prompt-templates";
+import { loadCapability } from "../discovery";
 // Embed command markdown files at build time
-import initMd from "@oh-my-pi/pi-coding-agent/prompts/agents/init.md" with { type: "text" };
-import { parseFrontmatter } from "@oh-my-pi/pi-coding-agent/utils/frontmatter";
+import initMd from "../prompts/agents/init.md" with { type: "text" };
+import { parseFrontmatter } from "../utils/frontmatter";
 
 const EMBEDDED_COMMANDS: { name: string; content: string }[] = [
 	{ name: "init.md", content: renderPromptTemplate(initMd) },
@@ -116,7 +115,7 @@ export async function discoverCommands(cwd: string): Promise<WorkflowCommand[]>
  * Get a command by name.
  */
 export function getCommand(commands: WorkflowCommand[], name: string): WorkflowCommand | undefined {
-	return commands.find((c) => c.name === name);
+	return commands.find(c => c.name === name);
 }
 
 /**