@oh-my-pi/pi-coding-agent 4.2.0 → 4.2.2

package/src/core/skills.ts

@@ -1,10 +1,11 @@
-import { readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { realpath } from "node:fs/promises";
 import { basename, join } from "node:path";
 import { minimatch } from "minimatch";
 import { skillCapability } from "../capability/skill";
 import type { SourceMeta } from "../capability/types";
 import type { Skill as CapabilitySkill, SkillFrontmatter as ImportedSkillFrontmatter } from "../discovery";
-import { loadSync } from "../discovery";
+import { loadCapability } from "../discovery";
 import { parseFrontmatter } from "../discovery/helpers";
 import type { SkillsSettings } from "./settings-manager";
 
@@ -215,7 +216,7 @@ export interface LoadSkillsOptions extends SkillsSettings {
  * Load skills from all configured locations.
  * Returns skills and any validation warnings.
  */
-export function loadSkills(options: LoadSkillsOptions = {}): LoadSkillsResult {
+export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadSkillsResult> {
 	const {
 		cwd = process.cwd(),
 		enabled = true,
@@ -247,7 +248,7 @@ export function loadSkills(options: LoadSkillsOptions = {}): LoadSkillsResult {
 	}
 
 	// Use capability API to load all skills
-	const result = loadSync<CapabilitySkill>(skillCapability.id, { cwd });
+	const result = await loadCapability<CapabilitySkill>(skillCapability.id, { cwd });
 
 	const skillMap = new Map<string, Skill>();
 	const realPathSet = new Set<string>();
@@ -265,28 +266,33 @@ export function loadSkills(options: LoadSkillsOptions = {}): LoadSkillsResult {
 		return ignoredSkills.some((pattern) => minimatch(name, pattern));
 	}
 
-	// Helper to add a skill to the map
-	function addSkill(capSkill: CapabilitySkill, sourceProvider: string) {
-		// Apply ignore filter (glob patterns) - takes precedence over include
-		if (matchesIgnorePatterns(capSkill.name)) {
-			return;
-		}
-		// Apply include filter (glob patterns)
-		if (!matchesIncludePatterns(capSkill.name)) {
-			return;
-		}
+	// Filter skills by source and patterns first
+	const filteredSkills = result.items.filter((capSkill) => {
+		if (!isSourceEnabled(capSkill._source)) return false;
+		if (matchesIgnorePatterns(capSkill.name)) return false;
+		if (!matchesIncludePatterns(capSkill.name)) return false;
+		return true;
+	});
+
+	// Batch resolve all real paths in parallel
+	const realPaths = await Promise.all(
+		filteredSkills.map(async (capSkill) => {
+			try {
+				return await realpath(capSkill.path);
+			} catch {
+				return capSkill.path;
+			}
+		}),
+	);
 
-		// Resolve symlinks to detect duplicate files
-		let realPath: string;
-		try {
-			realPath = realpathSync(capSkill.path);
-		} catch {
-			realPath = capSkill.path;
-		}
+	// Process skills with resolved paths
+	for (let i = 0; i < filteredSkills.length; i++) {
+		const capSkill = filteredSkills[i];
+		const resolvedPath = realPaths[i];
 
 		// Skip silently if we've already loaded this exact file (via symlink)
-		if (realPathSet.has(realPath)) {
-			return;
+		if (realPathSet.has(resolvedPath)) {
+			continue;
 		}
 
 		const existing = skillMap.get(capSkill.name);
@@ -302,46 +308,61 @@ export function loadSkills(options: LoadSkillsOptions = {}): LoadSkillsResult {
 				description: capSkill.frontmatter?.description || "",
 				filePath: capSkill.path,
 				baseDir: capSkill.path.replace(/\/SKILL\.md$/, ""),
-				source: `${sourceProvider}:${capSkill.level}`,
+				source: `${capSkill._source.provider}:${capSkill.level}`,
 				_source: capSkill._source,
 			};
 			skillMap.set(capSkill.name, skill);
-			realPathSet.add(realPath);
-		}
-	}
-
-	// Process skills from capability API
-	for (const capSkill of result.items) {
-		// Check if this source is enabled
-		if (!isSourceEnabled(capSkill._source)) {
-			continue;
+			realPathSet.add(resolvedPath);
 		}
-
-		addSkill(capSkill, capSkill._source.provider);
 	}
 
 	// Process custom directories - scan directly without using full provider system
+	const allCustomSkills: Array<{ skill: Skill; path: string }> = [];
 	for (const dir of customDirectories) {
 		const customSkills = scanDirectoryForSkills(dir);
 		for (const s of customSkills.skills) {
-			// Convert to capability format for addSkill processing
-			const capSkill: CapabilitySkill = {
-				name: s.name,
-				path: s.filePath,
-				content: "",
-				frontmatter: { description: s.description },
-				level: "user",
-				_source: {
-					provider: "custom",
-					providerName: "Custom",
-					path: s.filePath,
-					level: "user",
+			if (matchesIgnorePatterns(s.name)) continue;
+			if (!matchesIncludePatterns(s.name)) continue;
+			allCustomSkills.push({
+				skill: {
+					name: s.name,
+					description: s.description,
+					filePath: s.filePath,
+					baseDir: s.filePath.replace(/\/SKILL\.md$/, ""),
+					source: "custom:user",
+					_source: { provider: "custom", providerName: "Custom", path: s.filePath, level: "user" },
 				},
-			};
-			addSkill(capSkill, "custom");
+				path: s.filePath,
+			});
 		}
-		for (const warning of customSkills.warnings) {
-			collisionWarnings.push(warning);
+		collisionWarnings.push(...customSkills.warnings);
+	}
+
+	// Batch resolve custom skill paths
+	const customRealPaths = await Promise.all(
+		allCustomSkills.map(async ({ path }) => {
+			try {
+				return await realpath(path);
+			} catch {
+				return path;
+			}
+		}),
+	);
+
+	for (let i = 0; i < allCustomSkills.length; i++) {
+		const { skill } = allCustomSkills[i];
+		const resolvedPath = customRealPaths[i];
+		if (realPathSet.has(resolvedPath)) continue;
+
+		const existing = skillMap.get(skill.name);
+		if (existing) {
+			collisionWarnings.push({
+				skillPath: skill.filePath,
+				message: `name collision: "${skill.name}" already loaded from ${existing.filePath}, skipping this one`,
+			});
+		} else {
+			skillMap.set(skill.name, skill);
+			realPathSet.add(resolvedPath);
 		}
 	}
 

package/src/core/slash-commands.ts

@@ -1,6 +1,6 @@
 import { slashCommandCapability } from "../capability/slash-command";
 import type { SlashCommand } from "../discovery";
-import { loadSync } from "../discovery";
+import { loadCapability } from "../discovery";
 import { parseFrontmatter } from "../discovery/helpers";
 import { renderPromptTemplate } from "./prompt-templates";
 import { EMBEDDED_COMMAND_TEMPLATES } from "./tools/task/commands";
@@ -108,8 +108,8 @@ export interface LoadSlashCommandsOptions {
  * Load all custom slash commands using the capability API.
  * Loads from all registered providers (builtin, user, project).
  */
-export function loadSlashCommands(options: LoadSlashCommandsOptions = {}): FileSlashCommand[] {
-	const result = loadSync<SlashCommand>(slashCommandCapability.id, { cwd: options.cwd });
+export async function loadSlashCommands(options: LoadSlashCommandsOptions = {}): Promise<FileSlashCommand[]> {
+	const result = await loadCapability<SlashCommand>(slashCommandCapability.id, { cwd: options.cwd });
 
 	const fileCommands: FileSlashCommand[] = result.items.map((cmd) => {
 		const { description, body } = parseCommandTemplate(cmd.content);

package/src/core/system-prompt.ts

@@ -8,7 +8,7 @@ import { join } from "node:path";
 import chalk from "chalk";
 import { contextFileCapability } from "../capability/context-file";
 import { systemPromptCapability } from "../capability/system-prompt";
-import { type ContextFile, loadSync, type SystemPrompt as SystemPromptFile } from "../discovery/index";
+import { type ContextFile, loadCapability, type SystemPrompt as SystemPromptFile } from "../discovery/index";
 import customSystemPromptTemplate from "../prompts/system/custom-system-prompt.md" with { type: "text" };
 import systemPromptTemplate from "../prompts/system/system-prompt.md" with { type: "text" };
 import { renderPromptTemplate } from "./prompt-templates";
@@ -148,6 +148,45 @@ function stripQuotes(value: string): string {
 	return value.replace(/^"|"$/g, "");
 }
 
+const AGENTS_MD_PATTERN = "**/AGENTS.md";
+const AGENTS_MD_LIMIT = 200;
+
+interface AgentsMdSearch {
+	scopePath: string;
+	limit: number;
+	pattern: string;
+	files: string[];
+}
+
+function normalizePath(value: string): string {
+	return value.replace(/\\/g, "/");
+}
+
+function listAgentsMdFiles(root: string, limit: number): string[] {
+	try {
+		const entries = Array.from(
+			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"))
+			.sort();
+		return normalized.length > limit ? normalized.slice(0, limit) : normalized;
+	} catch {
+		return [];
+	}
+}
+
+function buildAgentsMdSearch(cwd: string): AgentsMdSearch {
+	const files = listAgentsMdFiles(cwd, AGENTS_MD_LIMIT);
+	return {
+		scopePath: ".",
+		limit: AGENTS_MD_LIMIT,
+		pattern: AGENTS_MD_PATTERN,
+		files,
+	};
+}
+
 function getOsName(): string {
 	switch (process.platform) {
 		case "win32":
@@ -519,12 +558,12 @@ export interface LoadContextFilesOptions {
  * Returns {path, content, depth} entries for all discovered context files.
  * Files are sorted by depth (descending) so files closer to cwd appear last/more prominent.
  */
-export function loadProjectContextFiles(
+export async function loadProjectContextFiles(
 	options: LoadContextFilesOptions = {},
-): Array<{ path: string; content: string; depth?: number }> {
+): Promise<Array<{ path: string; content: string; depth?: number }>> {
 	const resolvedCwd = options.cwd ?? process.cwd();
 
-	const result = loadSync(contextFileCapability.id, { cwd: resolvedCwd });
+	const result = await loadCapability(contextFileCapability.id, { cwd: resolvedCwd });
 
 	// Convert ContextFile items and preserve depth info
 	const files = result.items.map((item) => {
@@ -551,10 +590,10 @@ export function loadProjectContextFiles(
  * Load system prompt customization files (SYSTEM.md).
  * Returns combined content from all discovered SYSTEM.md files.
  */
-export function loadSystemPromptFiles(options: LoadContextFilesOptions = {}): string | null {
+export async function loadSystemPromptFiles(options: LoadContextFilesOptions = {}): Promise<string | null> {
 	const resolvedCwd = options.cwd ?? process.cwd();
 
-	const result = loadSync<SystemPromptFile>(systemPromptCapability.id, { cwd: resolvedCwd });
+	const result = await loadCapability<SystemPromptFile>(systemPromptCapability.id, { cwd: resolvedCwd });
 
 	if (result.items.length === 0) return null;
 
@@ -592,7 +631,7 @@ export interface BuildSystemPromptOptions {
 }
 
 /** Build the system prompt with tools, guidelines, and context */
-export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): string {
+export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}): Promise<string> {
 	const {
 		customPrompt,
 		tools,
@@ -609,7 +648,7 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 	const resolvedAppendPrompt = resolvePromptInput(appendSystemPrompt, "append system prompt");
 
 	// Load SYSTEM.md customization (prepended to prompt)
-	const systemPromptCustomization = loadSystemPromptFiles({ cwd: resolvedCwd });
+	const systemPromptCustomization = await loadSystemPromptFiles({ cwd: resolvedCwd });
 
 	const now = new Date();
 	const dateTime = now.toLocaleString("en-US", {
@@ -624,7 +663,8 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 	});
 
 	// Resolve context files: use provided or discover
-	const contextFiles = providedContextFiles ?? loadProjectContextFiles({ cwd: resolvedCwd });
+	const contextFiles = providedContextFiles ?? (await loadProjectContextFiles({ cwd: resolvedCwd }));
+	const agentsMdSearch = buildAgentsMdSearch(resolvedCwd);
 
 	// Build tool descriptions array
 	// Priority: toolNames (explicit list) > tools (Map) > defaults
@@ -648,7 +688,7 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 	// Resolve skills: use provided or discover
 	const skills =
 		providedSkills ??
-		(skillsSettings?.enabled !== false ? loadSkills({ ...skillsSettings, cwd: resolvedCwd }).skills : []);
+		(skillsSettings?.enabled !== false ? (await loadSkills({ ...skillsSettings, cwd: resolvedCwd })).skills : []);
 
 	// Get git context
 	const git = loadGitContext(resolvedCwd);
@@ -663,6 +703,7 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 			customPrompt: resolvedCustomPrompt,
 			appendPrompt: resolvedAppendPrompt ?? "",
 			contextFiles,
+			agentsMdSearch,
 			toolDescriptions: toolDescriptionsArray,
 			git,
 			skills: filteredSkills,
@@ -678,6 +719,7 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 		environment: getEnvironmentInfo(),
 		systemPromptCustomization: systemPromptCustomization ?? "",
 		contextFiles,
+		agentsMdSearch,
 		git,
 		skills: filteredSkills,
 		rules: rules ?? [],

package/src/core/tools/complete.ts

@@ -79,7 +79,7 @@ export function createCompleteTool(session: ToolSession) {
 		: Type.Any({ description: "Structured JSON output (no schema specified)" });
 
 	const completeParams = Type.Object({
-		data: dataSchema,
+		data: Type.Optional(dataSchema),
 		status: Type.Optional(
 			Type.Union([Type.Literal("success"), Type.Literal("aborted")], {
 				default: "success",
@@ -99,8 +99,11 @@ export function createCompleteTool(session: ToolSession) {
 		execute: async (_toolCallId, params) => {
 			const status = params.status ?? "success";
 
-			// Skip schema validation when aborting - the agent is giving up
+			// Skip validation when aborting - data is optional for aborts
 			if (status === "success") {
+				if (params.data === undefined) {
+					throw new Error("data is required when status is 'success'");
+				}
 				if (schemaError) {
 					throw new Error(`Invalid output schema: ${schemaError}`);
 				}

package/src/core/tools/edit.ts

@@ -19,7 +19,7 @@ import {
 	stripBom,
 } from "./edit-diff";
 import type { ToolSession } from "./index";
-import { createLspWritethrough, type FileDiagnosticsResult } from "./lsp/index";
+import { createLspWritethrough, type FileDiagnosticsResult, writethroughNoop } from "./lsp/index";
 import { resolveToCwd } from "./path-utils";
 import { createToolUIKit, getDiffStats, shortenPath, truncateDiffByHunk } from "./render-utils";
 
@@ -43,9 +43,12 @@ export interface EditToolDetails {
 
 export function createEditTool(session: ToolSession): AgentTool<typeof editSchema> {
 	const allowFuzzy = session.settings?.getEditFuzzyMatch() ?? true;
-	const enableDiagnostics = session.settings?.getLspDiagnosticsOnEdit() ?? false;
-	const enableFormat = session.settings?.getLspFormatOnWrite() ?? true;
-	const writethrough = createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics });
+	const enableLsp = session.enableLsp ?? true;
+	const enableDiagnostics = enableLsp ? (session.settings?.getLspDiagnosticsOnEdit() ?? false) : false;
+	const enableFormat = enableLsp ? (session.settings?.getLspFormatOnWrite() ?? true) : false;
+	const writethrough = enableLsp
+		? createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics })
+		: writethroughNoop;
 	return {
 		name: "edit",
 		label: "Edit",

package/src/core/tools/index.test.ts

@@ -34,6 +34,22 @@ describe("createTools", () => {
 		expect(names).toContain("web_search");
 	});
 
+	it("excludes lsp tool when session disables LSP", async () => {
+		const session = createTestSession({ enableLsp: false });
+		const tools = await createTools(session, ["read", "lsp", "write"]);
+		const names = tools.map((t) => t.name);
+
+		expect(names).toEqual(["read", "write"]);
+	});
+
+	it("excludes lsp tool when disabled", async () => {
+		const session = createTestSession({ enableLsp: false });
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		expect(names).not.toContain("lsp");
+	});
+
 	it("respects requested tool subset", async () => {
 		const session = createTestSession();
 		const tools = await createTools(session, ["read", "write"]);

package/src/core/tools/index.ts

@@ -92,6 +92,8 @@ export interface ToolSession {
 	cwd: string;
 	/** Whether UI is available */
 	hasUI: boolean;
+	/** Whether LSP integrations are enabled */
+	enableLsp?: boolean;
 	/** Event bus for tool/extension communication */
 	eventBus?: EventBus;
 	/** Output schema for structured completion (subagents) */
@@ -106,6 +108,12 @@ export interface ToolSession {
 	getModelString?: () => string | undefined;
 	/** Get the current session model string, regardless of how it was chosen */
 	getActiveModelString?: () => string | undefined;
+	/** Auth storage for passing to subagents (avoids re-discovery) */
+	authStorage?: import("../auth-storage").AuthStorage;
+	/** Model registry for passing to subagents (avoids re-discovery) */
+	modelRegistry?: import("../model-registry").ModelRegistry;
+	/** MCP manager for proxying MCP calls through parent */
+	mcpManager?: import("../mcp/manager").MCPManager;
 	/** Settings manager (optional) */
 	settings?: {
 		getImageAutoResize(): boolean;
@@ -154,23 +162,28 @@ export type ToolName = keyof typeof BUILTIN_TOOLS;
  */
 export async function createTools(session: ToolSession, toolNames?: string[]): Promise<Tool[]> {
 	const includeComplete = session.requireCompleteTool === true;
+	const enableLsp = session.enableLsp ?? true;
 	const requestedTools = toolNames && toolNames.length > 0 ? [...new Set(toolNames)] : undefined;
 	const allTools: Record<string, ToolFactory> = { ...BUILTIN_TOOLS, ...HIDDEN_TOOLS };
+	const isToolAllowed = (name: string) => (name === "lsp" ? enableLsp : true);
 	if (includeComplete && requestedTools && !requestedTools.includes("complete")) {
 		requestedTools.push("complete");
 	}
 
-	const entries = requestedTools
-		? requestedTools.filter((name) => name in allTools).map((name) => [name, allTools[name]] as const)
-		: [
-				...Object.entries(BUILTIN_TOOLS),
-				...(includeComplete ? ([["complete", HIDDEN_TOOLS.complete]] as const) : []),
-			];
+	const filteredRequestedTools = requestedTools?.filter((name) => name in allTools && isToolAllowed(name));
+
+	const entries =
+		filteredRequestedTools !== undefined
+			? filteredRequestedTools.map((name) => [name, allTools[name]] as const)
+			: [
+					...Object.entries(BUILTIN_TOOLS).filter(([name]) => isToolAllowed(name)),
+					...(includeComplete ? ([["complete", HIDDEN_TOOLS.complete]] as const) : []),
+				];
 	const results = await Promise.all(entries.map(([, factory]) => factory(session)));
 	const tools = results.filter((t): t is Tool => t !== null);
 
-	if (requestedTools) {
-		const allowed = new Set(requestedTools);
+	if (filteredRequestedTools !== undefined) {
+		const allowed = new Set(filteredRequestedTools);
 		return tools.filter((tool) => allowed.has(tool.name));
 	}
 

package/src/core/tools/lsp/index.ts

@@ -734,7 +734,10 @@ export function createLspWritethrough(cwd: string, options?: WritethroughOptions
 }
 
 /** Create an LSP tool */
-export function createLspTool(session: ToolSession): AgentTool<typeof lspSchema, LspToolDetails, Theme> {
+export function createLspTool(session: ToolSession): AgentTool<typeof lspSchema, LspToolDetails, Theme> | null {
+	if (session.enableLsp === false) {
+		return null;
+	}
 	return {
 		name: "lsp",
 		label: "LSP",

package/src/core/tools/ssh.ts

@@ -4,7 +4,7 @@ import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
 import type { SSHHost } from "../../capability/ssh";
 import { sshCapability } from "../../capability/ssh";
-import { loadSync } from "../../discovery/index";
+import { loadCapability } from "../../discovery/index";
 import type { Theme } from "../../modes/interactive/theme/theme";
 import sshDescriptionBase from "../../prompts/tools/ssh.md" with { type: "text" };
 import type { RenderResultOptions } from "../custom-tools/types";
@@ -97,11 +97,11 @@ function buildRemoteCommand(command: string, cwd: string | undefined, info: SSHH
 	return `cd -- ${quoteRemotePath(cwd)} && ${command}`;
 }
 
-function loadHosts(session: ToolSession): {
+async function loadHosts(session: ToolSession): Promise<{
 	hostNames: string[];
 	hostsByName: Map<string, SSHHost>;
-} {
-	const result = loadSync<SSHHost>(sshCapability.id, { cwd: session.cwd });
+}> {
+	const result = await loadCapability<SSHHost>(sshCapability.id, { cwd: session.cwd });
 	const hostsByName = new Map<string, SSHHost>();
 	for (const host of result.items) {
 		if (!hostsByName.has(host.name)) {
@@ -112,8 +112,8 @@ function loadHosts(session: ToolSession): {
 	return { hostNames, hostsByName };
 }
 
-export function createSshTool(session: ToolSession): AgentTool<typeof sshSchema> | null {
-	const { hostNames, hostsByName } = loadHosts(session);
+export async function createSshTool(session: ToolSession): Promise<AgentTool<typeof sshSchema> | null> {
+	const { hostNames, hostsByName } = await loadHosts(session);
 	if (hostNames.length === 0) {
 		return null;
 	}

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

@@ -6,19 +6,13 @@
 
 import * as path from "node:path";
 import { type SlashCommand, slashCommandCapability } from "../../../capability/slash-command";
-import { loadSync } from "../../../discovery";
+import { loadCapability } from "../../../discovery";
 
 // Embed command markdown files at build time
-import architectPlanMd from "../../../prompts/agents/architect-plan.md" with { type: "text" };
-import implementMd from "../../../prompts/agents/implement.md" with { type: "text" };
-import implementWithCriticMd from "../../../prompts/agents/implement-with-critic.md" with { type: "text" };
 import initMd from "../../../prompts/agents/init.md" with { type: "text" };
 import { renderPromptTemplate } from "../../prompt-templates";
 
 const EMBEDDED_COMMANDS: { name: string; content: string }[] = [
-	{ name: "architect-plan.md", content: renderPromptTemplate(architectPlanMd) },
-	{ name: "implement-with-critic.md", content: renderPromptTemplate(implementWithCriticMd) },
-	{ name: "implement.md", content: renderPromptTemplate(implementMd) },
 	{ name: "init.md", content: renderPromptTemplate(initMd) },
 ];
 
@@ -101,11 +95,11 @@ export function loadBundledCommands(): WorkflowCommand[] {
  *
  * Precedence (highest wins): .omp > .pi > .claude (project before user), then bundled
  */
-export function discoverCommands(cwd: string): WorkflowCommand[] {
+export async function discoverCommands(cwd: string): Promise<WorkflowCommand[]> {
 	const resolvedCwd = path.resolve(cwd);
 
 	// Load slash commands from capability API
-	const result = loadSync<SlashCommand>(slashCommandCapability.id, { cwd: resolvedCwd });
+	const result = await loadCapability<SlashCommand>(slashCommandCapability.id, { cwd: resolvedCwd });
 
 	const commands: WorkflowCommand[] = [];
 	const seen = new Set<string>();