@oh-my-pi/pi-coding-agent 4.2.3 → 4.3.1

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## [Unreleased]
 
+## [4.3.1] - 2026-01-11
+
+### Changed
+
+- Expanded system prompt with defensive reasoning guidance and assumption checks
+- Allowed agent frontmatter to override subagent thinking level, clamped to model capabilities
+
+### Fixed
+
+- Ensured reviewer agents use structured output schemas and include reported findings in task outputs
+
+## [4.3.0] - 2026-01-11
+
+### Added
+
+- Added Cursor provider support with browser-based OAuth authentication
+- Added default model configuration for Cursor provider (claude-sonnet-4-5)
+- Added execution bridge for Cursor tool calls including read, ls, grep, write, delete, shell, diagnostics, and MCP operations
+
+### Fixed
+
+- Improved fuzzy matching accuracy for edit operations when file and target have inconsistent indentation patterns
+
 ## [4.2.3] - 2026-01-11
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "4.2.3",
+	"version": "4.3.1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -39,10 +39,10 @@
 		"prepublishOnly": "bun run generate-template && bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "4.2.3",
-		"@oh-my-pi/pi-agent-core": "4.2.3",
-		"@oh-my-pi/pi-git-tool": "4.2.3",
-		"@oh-my-pi/pi-tui": "4.2.3",
+		"@oh-my-pi/pi-ai": "4.3.1",
+		"@oh-my-pi/pi-agent-core": "4.3.1",
+		"@oh-my-pi/pi-git-tool": "4.3.1",
+		"@oh-my-pi/pi-tui": "4.3.1",
 		"@openai/agents": "^0.3.7",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",

package/src/cli/update-cli.ts

@@ -144,8 +144,8 @@ async function updateViaBun(): Promise<void> {
 	try {
 		execSync(`bun update -g ${PACKAGE}`, { stdio: "inherit" });
 		console.log(chalk.green(`\n${theme.status.success} Update complete`));
-	} catch {
-		throw new Error("bun update failed");
+	} catch (error) {
+		throw new Error("bun update failed", { cause: error });
 	}
 }
 

package/src/config.ts

@@ -1,9 +1,9 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
-
 // Embed package.json at build time for config
 import packageJson from "../package.json" with { type: "json" };
+import { logger } from "./core/logger";
 
 // =============================================================================
 // App Config (from embedded package.json)
@@ -244,8 +244,8 @@ export function readConfigFile<T = unknown>(
 					content: JSON.parse(content) as T,
 				};
 			}
-		} catch {
-			// Continue to next file on parse error
+		} catch (error) {
+			logger.warn("Failed to parse config file", { path: filePath, error: String(error) });
 		}
 	}
 
@@ -275,8 +275,8 @@ export function readAllConfigFiles<T = unknown>(
 					content: JSON.parse(content) as T,
 				});
 			}
-		} catch {
-			// Skip files that fail to parse
+		} catch (error) {
+			logger.warn("Failed to parse config file", { path: filePath, error: String(error) });
 		}
 	}
 

package/src/core/auth-storage.ts

@@ -9,6 +9,7 @@ import {
 	getOAuthApiKey,
 	loginAnthropic,
 	loginAntigravity,
+	loginCursor,
 	loginGeminiCli,
 	loginGitHubCopilot,
 	loginOpenAICodex,
@@ -585,6 +586,12 @@ export class AuthStorage {
 					onManualCodeInput: callbacks.onManualCodeInput,
 				});
 				break;
+			case "cursor":
+				credentials = await loginCursor(
+					(url) => callbacks.onAuth({ url }),
+					callbacks.onProgress ? () => callbacks.onProgress?.("Waiting for browser authentication...") : undefined,
+				);
+				break;
 			default:
 				throw new Error(`Unknown OAuth provider: ${provider}`);
 		}
@@ -932,7 +939,12 @@ export class AuthStorage {
 
 			this.recordSessionCredential(provider, sessionId, "oauth", selection.index);
 			return result.apiKey;
-		} catch {
+		} catch (error) {
+			logger.warn("OAuth token refresh failed, removing credential", {
+				provider,
+				index: selection.index,
+				error: String(error),
+			});
 			this.removeCredentialAt(provider, selection.index);
 			if (this.getCredentialsForProvider(provider).some((credential) => credential.type === "oauth")) {
 				return this.getApiKey(provider, sessionId, options);

package/src/core/cursor/exec-bridge.ts

@@ -0,0 +1,234 @@
+import { randomUUID } from "node:crypto";
+import { rmSync, statSync } from "node:fs";
+import type {
+	AgentEvent,
+	AgentTool,
+	AgentToolContext,
+	AgentToolResult,
+	AgentToolUpdateCallback,
+} from "@oh-my-pi/pi-agent-core";
+import type { CursorExecHandlers, CursorMcpCall, ToolResultMessage } from "@oh-my-pi/pi-ai";
+import { resolveToCwd } from "../tools/path-utils";
+
+interface CursorExecBridgeOptions {
+	cwd: string;
+	tools: Map<string, AgentTool>;
+	getToolContext?: () => AgentToolContext | undefined;
+	emitEvent?: (event: AgentEvent) => void;
+}
+
+function createToolResultMessage(
+	toolCallId: string,
+	toolName: string,
+	result: AgentToolResult<unknown>,
+	isError: boolean,
+): ToolResultMessage {
+	return {
+		role: "toolResult",
+		toolCallId,
+		toolName,
+		content: result.content,
+		details: result.details,
+		isError,
+		timestamp: Date.now(),
+	};
+}
+
+function buildToolErrorResult(message: string): AgentToolResult<unknown> {
+	return {
+		content: [{ type: "text", text: message }],
+		details: {},
+	};
+}
+
+async function executeTool(
+	options: CursorExecBridgeOptions,
+	toolName: string,
+	toolCallId: string,
+	args: Record<string, unknown>,
+): Promise<ToolResultMessage> {
+	const tool = options.tools.get(toolName);
+	if (!tool) {
+		const result = buildToolErrorResult(`Tool "${toolName}" not available`);
+		return createToolResultMessage(toolCallId, toolName, result, true);
+	}
+
+	options.emitEvent?.({ type: "tool_execution_start", toolCallId, toolName, args });
+
+	let result: AgentToolResult<unknown>;
+	let isError = false;
+
+	const onUpdate: AgentToolUpdateCallback<unknown> | undefined = options.emitEvent
+		? (partialResult) => {
+				options.emitEvent?.({
+					type: "tool_execution_update",
+					toolCallId,
+					toolName,
+					args,
+					partialResult,
+				});
+			}
+		: undefined;
+
+	try {
+		result = await tool.execute(
+			toolCallId,
+			args as Record<string, unknown>,
+			undefined,
+			onUpdate,
+			options.getToolContext?.(),
+		);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		result = buildToolErrorResult(message);
+		isError = true;
+	}
+
+	options.emitEvent?.({ type: "tool_execution_end", toolCallId, toolName, result, isError });
+
+	return createToolResultMessage(toolCallId, toolName, result, isError);
+}
+
+async function executeDelete(options: CursorExecBridgeOptions, pathArg: string, toolCallId: string) {
+	const toolName = "delete";
+	options.emitEvent?.({ type: "tool_execution_start", toolCallId, toolName, args: { path: pathArg } });
+
+	const absolutePath = resolveToCwd(pathArg, options.cwd);
+	let isError = false;
+	let result: AgentToolResult<unknown>;
+
+	try {
+		const stat = statSync(absolutePath, { throwIfNoEntry: false });
+		if (!stat) {
+			throw new Error(`File not found: ${pathArg}`);
+		}
+		if (!stat.isFile()) {
+			throw new Error(`Path is not a file: ${pathArg}`);
+		}
+
+		rmSync(absolutePath);
+
+		const sizeText = stat.size ? ` (${stat.size} bytes)` : "";
+		const message = `Deleted ${pathArg}${sizeText}`;
+		result = { content: [{ type: "text", text: message }], details: {} };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		result = buildToolErrorResult(message);
+		isError = true;
+	}
+
+	options.emitEvent?.({ type: "tool_execution_end", toolCallId, toolName, result, isError });
+	return createToolResultMessage(toolCallId, toolName, result, isError);
+}
+
+function decodeToolCallId(toolCallId?: string): string {
+	return toolCallId && toolCallId.length > 0 ? toolCallId : randomUUID();
+}
+
+function decodeMcpArgs(rawArgs: Record<string, Uint8Array>): Record<string, unknown> {
+	const decoded: Record<string, unknown> = {};
+	for (const [key, value] of Object.entries(rawArgs)) {
+		const text = new TextDecoder().decode(value);
+		try {
+			decoded[key] = JSON.parse(text);
+		} catch {
+			decoded[key] = text;
+		}
+	}
+	return decoded;
+}
+
+function formatMcpToolErrorMessage(toolName: string, availableTools: string[]): string {
+	const list = availableTools.length > 0 ? availableTools.join(", ") : "none";
+	return `MCP tool "${toolName}" not found. Available tools: ${list}`;
+}
+
+export function createCursorExecHandlers(options: CursorExecBridgeOptions): CursorExecHandlers {
+	return {
+		read: async (args) => {
+			const toolCallId = decodeToolCallId(args.toolCallId);
+			const toolResultMessage = await executeTool(options, "read", toolCallId, { path: args.path });
+			return toolResultMessage;
+		},
+		ls: async (args) => {
+			const toolCallId = decodeToolCallId(args.toolCallId);
+			const toolResultMessage = await executeTool(options, "ls", toolCallId, { path: args.path });
+			return toolResultMessage;
+		},
+		grep: async (args) => {
+			const toolCallId = decodeToolCallId(args.toolCallId);
+			const toolResultMessage = await executeTool(options, "grep", toolCallId, {
+				pattern: args.pattern,
+				path: args.path || undefined,
+				glob: args.glob || undefined,
+				outputMode: args.outputMode || undefined,
+				context: args.context ?? args.contextBefore ?? args.contextAfter ?? undefined,
+				ignoreCase: args.caseInsensitive || undefined,
+				type: args.type || undefined,
+				headLimit: args.headLimit ?? undefined,
+				multiline: args.multiline || undefined,
+			});
+			return toolResultMessage;
+		},
+		write: async (args) => {
+			const toolCallId = decodeToolCallId(args.toolCallId);
+			const content = args.fileText ?? new TextDecoder().decode(args.fileBytes ?? new Uint8Array());
+			const toolResultMessage = await executeTool(options, "write", toolCallId, {
+				path: args.path,
+				content,
+			});
+			return toolResultMessage;
+		},
+		delete: async (args) => {
+			const toolCallId = decodeToolCallId(args.toolCallId);
+			const toolResultMessage = await executeDelete(options, args.path, toolCallId);
+			return toolResultMessage;
+		},
+		shell: async (args) => {
+			const toolCallId = decodeToolCallId(args.toolCallId);
+			const timeoutSeconds =
+				args.timeout && args.timeout > 0
+					? args.timeout > 1000
+						? Math.ceil(args.timeout / 1000)
+						: args.timeout
+					: undefined;
+			const toolResultMessage = await executeTool(options, "bash", toolCallId, {
+				command: args.command,
+				workdir: args.workingDirectory || undefined,
+				timeout: timeoutSeconds,
+			});
+			return toolResultMessage;
+		},
+		diagnostics: async (args) => {
+			const toolCallId = decodeToolCallId(args.toolCallId);
+			const toolResultMessage = await executeTool(options, "lsp", toolCallId, {
+				action: "diagnostics",
+				file: args.path,
+			});
+			return toolResultMessage;
+		},
+		mcp: async (call: CursorMcpCall) => {
+			const toolName = call.toolName || call.name;
+			const toolCallId = decodeToolCallId(call.toolCallId);
+			const tool = options.tools.get(toolName);
+			if (!tool) {
+				const availableTools = Array.from(options.tools.keys()).filter((name) => name.startsWith("mcp_"));
+				const message = formatMcpToolErrorMessage(toolName, availableTools);
+				const toolResult: ToolResultMessage = {
+					role: "toolResult",
+					toolCallId,
+					toolName,
+					content: [{ type: "text", text: message }],
+					details: {},
+					isError: true,
+					timestamp: Date.now(),
+				};
+				return toolResult;
+			}
+
+			const args = Object.keys(call.args ?? {}).length > 0 ? call.args : decodeMcpArgs(call.rawArgs ?? {});
+			const toolResultMessage = await executeTool(options, toolName, toolCallId, args);
+			return toolResultMessage;
+		},
+	};
+}

package/src/core/custom-commands/loader.ts

@@ -11,6 +11,7 @@ import * as typebox from "@sinclair/typebox";
 import { getAgentDir, getConfigDirs } from "../../config";
 import * as piCodingAgent from "../../index";
 import { execCommand } from "../exec";
+import { logger } from "../logger";
 import { createReviewCommand } from "./bundled/review";
 import { createWorktreeCommand } from "./bundled/wt";
 import type {
@@ -110,7 +111,8 @@ export function discoverCustomCommands(options: DiscoverCustomCommandsOptions =
 		let entries: Dirent[];
 		try {
 			entries = readdirSync(commandsDir, { withFileTypes: true });
-		} catch {
+		} catch (error) {
+			logger.warn("Failed to read custom commands directory", { path: commandsDir, error: String(error) });
 			continue;
 		}
 		for (const entry of entries) {

package/src/core/custom-tools/loader.ts

@@ -5,11 +5,11 @@
  * to avoid import resolution issues with custom tools loaded from user directories.
  */
 
-import * as os from "node:os";
 import * as path from "node:path";
 import * as typebox from "@sinclair/typebox";
 import { toolCapability } from "../../capability/tool";
 import { type CustomTool, loadCapability } from "../../discovery";
+import { expandPath } from "../../discovery/helpers";
 import * as piCodingAgent from "../../index";
 import { theme } from "../../modes/interactive/theme/theme";
 import type { ExecOptions } from "../exec";
@@ -19,23 +19,6 @@ import { logger } from "../logger";
 import { getAllPluginToolPaths } from "../plugins/loader";
 import type { CustomToolAPI, CustomToolFactory, CustomToolsLoadResult, LoadedCustomTool } from "./types";
 
-const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
-
-function normalizeUnicodeSpaces(str: string): string {
-	return str.replace(UNICODE_SPACES, " ");
-}
-
-function expandPath(p: string): string {
-	const normalized = normalizeUnicodeSpaces(p);
-	if (normalized.startsWith("~/")) {
-		return path.join(os.homedir(), normalized.slice(2));
-	}
-	if (normalized.startsWith("~")) {
-		return path.join(os.homedir(), normalized.slice(1));
-	}
-	return normalized;
-}
-
 /**
  * Resolve tool path.
  * - Absolute paths used as-is

package/src/core/extensions/loader.ts

@@ -3,13 +3,12 @@
  */
 
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { homedir } from "node:os";
 import * as path from "node:path";
 import type { KeyId } from "@oh-my-pi/pi-tui";
 import * as TypeBox from "@sinclair/typebox";
 import { type ExtensionModule, extensionModuleCapability } from "../../capability/extension-module";
 import { loadCapability } from "../../discovery";
-import { getExtensionNameFromPath } from "../../discovery/helpers";
+import { expandPath, getExtensionNameFromPath } from "../../discovery/helpers";
 import * as piCodingAgent from "../../index";
 import { createEventBus, type EventBus } from "../event-bus";
 import type { ExecOptions } from "../exec";
@@ -27,23 +26,6 @@ import type {
 	ToolDefinition,
 } from "./types";
 
-const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
-
-function normalizeUnicodeSpaces(str: string): string {
-	return str.replace(UNICODE_SPACES, " ");
-}
-
-function expandPath(p: string): string {
-	const normalized = normalizeUnicodeSpaces(p);
-	if (normalized.startsWith("~/")) {
-		return path.join(homedir(), normalized.slice(2));
-	}
-	if (normalized.startsWith("~")) {
-		return path.join(homedir(), normalized.slice(1));
-	}
-	return normalized;
-}
-
 function resolvePath(extPath: string, cwd: string): string {
 	const expanded = expandPath(extPath);
 	if (path.isAbsolute(expanded)) {
@@ -291,7 +273,8 @@ function readExtensionManifest(packageJsonPath: string): ExtensionManifest | nul
 			return manifest;
 		}
 		return null;
-	} catch {
+	} catch (error) {
+		logger.warn("Failed to read extension manifest", { path: packageJsonPath, error: String(error) });
 		return null;
 	}
 }
@@ -370,7 +353,8 @@ function discoverExtensionsInDir(dir: string): string[] {
 				}
 			}
 		}
-	} catch {
+	} catch (error) {
+		logger.warn("Failed to discover extensions in directory", { path: dir, error: String(error) });
 		return [];
 	}
 

package/src/core/hooks/loader.ts

@@ -2,12 +2,12 @@
  * Hook loader - loads TypeScript hook modules using native Bun import.
  */
 
-import * as os from "node:os";
 import * as path from "node:path";
 import * as typebox from "@sinclair/typebox";
 import { hookCapability } from "../../capability/hook";
 import type { Hook } from "../../discovery";
 import { loadCapability } from "../../discovery";
+import { expandPath } from "../../discovery/helpers";
 import * as piCodingAgent from "../../index";
 import { logger } from "../logger";
 import type { HookMessage } from "../messages";
@@ -84,23 +84,6 @@ export interface LoadHooksResult {
 	errors: Array<{ path: string; error: string }>;
 }
 
-const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
-
-function normalizeUnicodeSpaces(str: string): string {
-	return str.replace(UNICODE_SPACES, " ");
-}
-
-function expandPath(p: string): string {
-	const normalized = normalizeUnicodeSpaces(p);
-	if (normalized.startsWith("~/")) {
-		return path.join(os.homedir(), normalized.slice(2));
-	}
-	if (normalized.startsWith("~")) {
-		return path.join(os.homedir(), normalized.slice(1));
-	}
-	return normalized;
-}
-
 /**
  * Resolve hook path.
  * - Absolute paths used as-is

package/src/core/keybindings.ts

@@ -10,6 +10,7 @@ import {
 	setEditorKeybindings,
 } from "@oh-my-pi/pi-tui";
 import { getAgentDir } from "../config";
+import { logger } from "./logger";
 
 /**
  * Application-level actions (coding agent specific).
@@ -136,7 +137,8 @@ export class KeybindingsManager {
 		if (!existsSync(path)) return {};
 		try {
 			return JSON.parse(readFileSync(path, "utf-8"));
-		} catch {
+		} catch (error) {
+			logger.warn("Failed to parse keybindings config", { path, error: String(error) });
 			return {};
 		}
 	}

package/src/core/logger.ts

@@ -10,11 +10,10 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import winston from "winston";
 import DailyRotateFile from "winston-daily-rotate-file";
-import { CONFIG_DIR_NAME } from "../config";
 
 /** Get the logs directory (~/.omp/logs/) */
 function getLogsDir(): string {
-	return join(homedir(), CONFIG_DIR_NAME, "logs");
+	return join(homedir(), ".omp", "logs");
 }
 
 /** Ensure logs directory exists */

package/src/core/model-resolver.ts

@@ -19,6 +19,7 @@ export const defaultModelPerProvider: Record<KnownProvider, string> = {
 	"google-antigravity": "gemini-3-pro-high",
 	"google-vertex": "gemini-2.5-pro",
 	"github-copilot": "gpt-4o",
+	cursor: "claude-sonnet-4-5",
 	openrouter: "openai/gpt-5.1-codex",
 	xai: "grok-4-fast-non-reasoning",
 	groq: "openai/gpt-oss-120b",

package/src/core/prompt-templates.ts

@@ -1,6 +1,7 @@
 import { join, resolve } from "node:path";
 import Handlebars from "handlebars";
 import { CONFIG_DIR_NAME, getPromptsDir } from "../config";
+import { logger } from "./logger";
 
 /**
  * Represents a prompt template loaded from a markdown file
@@ -448,12 +449,12 @@ async function loadTemplatesFromDir(
 						source: sourceStr,
 					});
 				}
-			} catch (_error) {
-				// Silently skip files that can't be read
+			} catch (error) {
+				logger.warn("Failed to load prompt template", { path: fullPath, error: String(error) });
 			}
 		}
-	} catch (_error) {
-		// Silently skip directories that can't be read
+	} catch (error) {
+		logger.warn("Failed to scan prompt templates directory", { dir, error: String(error) });
 	}
 
 	return templates;

package/src/core/sdk.ts

@@ -27,8 +27,8 @@
  */
 
 import { join } from "node:path";
-import { Agent, type AgentMessage, type AgentTool, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Message, Model } from "@oh-my-pi/pi-ai";
+import { Agent, type AgentEvent, type AgentMessage, type AgentTool, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import { type Message, type Model, supportsXhigh } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import chalk from "chalk";
 // Import discovery to register all providers on startup
@@ -40,6 +40,7 @@ import { initializeWithSettings } from "../discovery";
 import { registerAsyncCleanup } from "../modes/cleanup";
 import { AgentSession } from "./agent-session";
 import { AuthStorage } from "./auth-storage";
+import { createCursorExecHandlers } from "./cursor/exec-bridge";
 import {
 	type CustomCommandsLoadResult,
 	loadCustomCommands as loadCustomCommandsInternal,
@@ -630,6 +631,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	// Clamp to model capabilities
 	if (!model || !model.reasoning) {
 		thinkingLevel = "off";
+	} else if (thinkingLevel === "xhigh" && !supportsXhigh(model)) {
+		thinkingLevel = "high";
 	}
 
 	let skills: Skill[];
@@ -854,6 +857,14 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	}
 	time("combineTools");
 
+	let cursorEventEmitter: ((event: AgentEvent) => void) | undefined;
+	const cursorExecHandlers = createCursorExecHandlers({
+		cwd,
+		tools: toolRegistry,
+		getToolContext: toolContextStore.getContext,
+		emitEvent: (event) => cursorEventEmitter?.(event),
+	});
+
 	const rebuildSystemPrompt = async (toolNames: string[], tools: Map<string, AgentTool>): Promise<string> => {
 		toolContextStore.setToolNames(toolNames);
 		const defaultPrompt = await buildSystemPromptInternal({
@@ -964,7 +975,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			}
 			return key;
 		},
+		cursorExecHandlers,
 	});
+	cursorEventEmitter = (event) => agent.emitExternalEvent(event);
 	time("createAgent");
 
 	// Restore messages if session has existing data
@@ -1010,8 +1023,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			});
 			lspServers = result.servers;
 			time("warmupLspServers");
-		} catch {
-			// Ignore warmup errors
+		} catch (error) {
+			logger.warn("LSP server warmup failed", { cwd, error: String(error) });
 		}
 	}
 

package/src/core/skills.ts

@@ -7,6 +7,7 @@ import type { SourceMeta } from "../capability/types";
 import type { Skill as CapabilitySkill, SkillFrontmatter as ImportedSkillFrontmatter } from "../discovery";
 import { loadCapability } from "../discovery";
 import { parseFrontmatter } from "../discovery/helpers";
+import { logger } from "./logger";
 import type { SkillsSettings } from "./settings-manager";
 
 // Re-export SkillFrontmatter for backward compatibility
@@ -67,8 +68,8 @@ export function loadSkillsFromDir(options: LoadSkillsFromDirOptions): LoadSkills
 					source: options.source,
 				});
 			}
-		} catch {
-			// Skip invalid skills
+		} catch (error) {
+			logger.warn("Failed to load skill", { path: skillFile, error: String(error) });
 		}
 	}
 
@@ -131,8 +132,8 @@ function scanDirectoryForSkills(dir: string): LoadSkillsResult {
 					source: "custom",
 				});
 			}
-		} catch {
-			// Skip invalid skills
+		} catch (error) {
+			logger.warn("Failed to load skill", { path: skillFile, error: String(error) });
 		}
 	}